Elysian Shadows

gamenovice wrote:I am aware of the option of using databases, and in fact am considering using SQL Lite in the future. But I want to see if it's possible to devise a data structure or system first before I resort to databases.

std::string query = "attack > 40 AND item_name CONTAINS 'monado'";

attack > 40 {OPER} item_name CONTAINS 'monado'

attack {COMP} 40 {OPER} item_name {COMP} 'monado'

attack {COMP} {NUMBER} {OPER} item_name {COMP} {STRING}

{PROP} {COMP} {NUMBER} {OPER} {PROP} {COMP} {STRING}

attack > 40

enum Comparator { GREATER_THAN, LESS_THAN, EQUALS, CONTAINS };

struct Expression {
    std::string prop;
    Comparator comp;
    std::string value;
};

struct Query {
    Expression[] expressions;
};

Item[] QueryItems(std::string query)
{
    Item[] result;

    bool itemIsMatch;
    foreach(Item* item in ItemMgr->GetItems())
    {
        itemIsMatch = true;
        foreach(expr in query->expressions)
        {
            if(!Compare(item, expr->prop, expr->comp, expr->value))
            {
                itemIsMatch = false;
                break;
            }
            
            if(itemIsMatch)
                result.Add(item);
        }
    }

    return result;
}

bool Compare(Item* item, std::string prop, Comparator comp, std::string value)
{
    std::string actualValue;

    //TODO: Switch prop, get actual property value
    if(prop == "attack")
        return Compare(item->attack, comp, (int)value); //Cast "value" to match real type
    else if(prop == "item_name)
        return Compare(item->item_name, comp, value);
}

bool Compare(int actualValue, Comparator comp, int value)
{
    //TODO: Switch comp, implement logic for each comparator, return true/false
}

bool Compare(std::string actualValue, Comparator comp, std::string value)
{
    //TODO: Switch comp, implement logic for each comparator, return true/false
}

gamenovice wrote:Also do you happen to know any open source query language projects? I'd love to take a look at one sometime..

gamenovice wrote:..(call me an idiot if SQL happens to be one... I'm not too familiar with query languages and this is my first venture)

List<Item> matches =
    (from item in ItemMgr.GetItems()
    where item.Attack > 40
    and item.ItemName.Contains("monado")
    select item).ToList();

auto result =    from_array (ItemMgr.GetItems())
              >> where ([](Item* item) {return (item->attack > 40 && strContains(item->item_name, "monado"));})
              ;

K-Bal wrote:I didn't thoroughly read the whole SQL part, but I just wanted to point out that using inheritance for different item types might not be a good idea, in the same way that inheritance is not a good model for different game entities. Also how big can a game inventory possibly be that search performance even becomes an issue?

gamenovice wrote:so i could use the component model for that instead? well it takes away the need of polymorphism, but it seems like that would solve my big problem of type checking before downcasting

gamenovice wrote:Loving the way the source code is organized. Makes it really easy to understand how the component system works.... is it ok if i use this code to learn more about components?

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
Version 2, December 2004

Copyright (C) 2015 Dan Bechard

Everyone is permitted to copy and distribute verbatim or modified
copies of this license document, and changing it is allowed as long
as the name is changed.

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. You just DO WHAT THE FUCK YOU WANT TO.