FactoryCraft-Server/FactoryCraft/ItemFilter.cpp

#include "ItemFilter.h"

#include "Game.h"
#include "Item.h"
#include "ItemSlot.h"
#include "ItemStack.h"
#include "ItemType.h"
#include "UIMLBuilder.h"

ItemFilter::ItemFilter()
    : ReferenceCounter()
{}

bool ItemFilter::matchItem(const Item* zItem) const
{
    return 1;
}

bool ItemFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    return zSlot->zStack() ? matchItem(zSlot->zStack()->zItem()) : 0;
}

bool ItemFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    return 1;
}

CombinedItemFilter::CombinedItemFilter()
    : ItemFilter(),
      op([](bool a, bool b) { return false; })
{}

CombinedItemFilter::CombinedItemFilter(
    Framework::RCArray<ItemFilter> filters, std::function<bool(bool, bool)> op)
    : ItemFilter(),
      filters(filters),
      op(op)
{}

bool CombinedItemFilter::matchItem(const Item* zItem) const
{
    bool result = false;
    for (int i = 0; i < filters.getEntryCount(); i++)
    {
        if (i == 0)
            result = filters.z(i)->matchItem(zItem);
        else
            result = op(result, filters.z(i)->matchItem(zItem));
    }
    return result;
}

bool CombinedItemFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    bool result = false;
    for (int i = 0; i < filters.getEntryCount(); i++)
    {
        if (i == 0)
            result = filters.z(i)->matchSourceSlot(zSlot);
        else
            result = op(result, filters.z(i)->matchSourceSlot(zSlot));
    }
    return result;
}

bool CombinedItemFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    bool result = false;
    for (int i = 0; i < filters.getEntryCount(); i++)
    {
        if (i == 0)
            result = filters.z(i)->matchTargetSlot(zSlot);
        else
            result = op(result, filters.z(i)->matchTargetSlot(zSlot));
    }
    return result;
}

UIMLItemFilterBuilder* CombinedItemFilter::getUIML() const
{
    if (filters.getEntryCount() == 0)
    {
        throw std::runtime_error(
            "Cannot build UIML for CombinedItemFilter with no filters");
    }
    if (filters.getEntryCount() == 1)
    {
        return filters.z(0)->getUIML();
    }
    else
    {
        UIMLItemFilterBuilder* builder = 0;
        for (int i = 0; i < filters.getEntryCount(); i++)
        {
            if (builder == 0)
            {
                builder = filters.z(i)->getUIML();
            }
            else
            {
                builder = UIMLBuilder::createOperatorItemFilter()
                              ->setOperator(op)
                              ->setOperands(builder, filters.z(i)->getUIML())
                              ->build();
            }
        }
        return builder;
    }
}

void CombinedItemFilter::addFilter(ItemFilter* filter)
{
    filters.add(filter);
}

const Framework::RCArray<ItemFilter>& CombinedItemFilter::getFilters() const
{
    return filters;
}

void CombinedItemFilter::setOp(std::function<bool(bool, bool)> op)
{
    this->op = op;
}

std::function<bool(bool, bool)> CombinedItemFilter::getOp() const
{
    return op;
}

CombinedItemFilterFactory::CombinedItemFilterFactory()
    : SubTypeFactory()
{}

CombinedItemFilter* CombinedItemFilterFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    CombinedItemFilter* result = new CombinedItemFilter();
    std::function<bool(bool, bool)> func;
    Framework::Text op = zJson->zValue("operator")->asString()->getString();
    if (op.isEqual("or"))
    {
        func = [](bool a, bool b) { return a || b; };
    }
    else if (op.isEqual("and"))
    {
        func = [](bool a, bool b) { return a && b; };
    }
    else if (op.isEqual("xor"))
    {
        func = [](bool a, bool b) { return (!a || !b) && (a || b); };
    }
    else if (op.isEqual("nor"))
    {
        func = [](bool a, bool b) { return !(a || b); };
    }
    else if (op.isEqual("nand"))
    {
        func = [](bool a, bool b) { return !(a && b); };
    }
    else if (op.isEqual("left"))
    {
        func = [](bool a, bool b) { return a; };
    }
    else if (op.isEqual("right"))
    {
        func = [](bool a, bool b) { return b; };
    }
    else if (op.isEqual("onlyLeft"))
    {
        func = [](bool a, bool b) { return a && !b; };
    }
    else if (op.isEqual("onlyRight"))
    {
        func = [](bool a, bool b) { return !a && b; };
    }
    else if (op.isEqual("notLeft"))
    {
        func = [](bool a, bool b) { return !a; };
    }
    else if (op.isEqual("notRight"))
    {
        func = [](bool a, bool b) { return !b; };
    }
    else if (op.isEqual("eq"))
    {
        func = [](bool a, bool b) { return a == b; };
    }
    else if (op.isEqual("leftOrEq"))
    {
        func = [](bool a, bool b) { return a || (a == b); };
    }
    else if (op.isEqual("rightOrEq"))
    {
        func = [](bool a, bool b) { return b || (a == b); };
    }
    else if (op.isEqual("true"))
    {
        func = [](bool a, bool b) { return true; };
    }
    else
    {
        func = [](bool a, bool b) { return false; };
    }
    result->setOp(func);
    Framework::RCArray<ItemFilter> filters;
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("filters")->asArray())
    {
        result->addFilter(
            Game::INSTANCE->zTypeRegistry()->fromJson<ItemFilter>(value));
    }
    return result;
}

Framework::JSON::JSONObject* CombinedItemFilterFactory::toJsonObject(
    CombinedItemFilter* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    Framework::Text op;
    std::function<bool(bool, bool)> func = zObject->getOp();
    if (func(0, 0))
    {
        if (func(0, 1))
        {
            if (func(1, 0))
            {
                if (func(1, 1))
                {
                    op = "true";
                }
                else
                {
                    op = "nand";
                }
            }
            else
            {
                if (func(1, 1))
                {
                    op = "rightOrEq";
                }
                else
                {
                    op = "notLeft";
                }
            }
        }
        else
        {
            if (func(1, 0))
            {
                if (func(1, 1))
                {
                    op = "leftOrEq";
                }
                else
                {
                    op = "notRight";
                }
            }
            else
            {
                if (func(1, 1))
                {
                    op = "eq";
                }
                else
                {
                    op = "nor";
                }
            }
        }
    }
    else
    {
        if (func(0, 1))
        {
            if (func(1, 0))
            {
                if (func(1, 1))
                {
                    op = "or";
                }
                else
                {
                    op = "xor";
                }
            }
            else
            {
                if (func(1, 1))
                {
                    op = "right";
                }
                else
                {
                    op = "onlyRight";
                }
            }
        }
        else
        {
            if (func(1, 0))
            {
                if (func(1, 1))
                {
                    op = "left";
                }
                else
                {
                    op = "onlyLeft";
                }
            }
            else
            {
                if (func(1, 1))
                {
                    op = "and";
                }
                else
                {
                    op = "false";
                }
            }
        }
    }
    result->addValue("operator", new Framework::JSON::JSONString(op));
    Framework::JSON::JSONArray* filters = new Framework::JSON::JSONArray();
    for (ItemFilter* filter : zObject->getFilters())
    {
        filters->addValue(Game::INSTANCE->zTypeRegistry()->toJson(filter));
    }
    result->addValue("filters", filters);
    return result;
}

JSONObjectValidationBuilder* CombinedItemFilterFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredString("operator")
        ->whichIsOneOf({"or",
            "and",
            "xor",
            "nor",
            "nand",
            "left",
            "right",
            "onlyLeft",
            "onlyRight",
            "notLeft",
            "notRight",
            "eq",
            "leftOrEq",
            "rightOrEq",
            "true",
            "false"})
        ->finishString()
        ->withRequiredArray("filters")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<ItemFilter>())
        ->finishArray();
}

const char* CombinedItemFilterFactory::getTypeToken() const
{
    return "operator";
}

AnyItemFilter::AnyItemFilter()
    : ItemFilter()
{}

bool AnyItemFilter::matchItem(const Item* zItem) const
{
    return true;
}

UIMLItemFilterBuilder* AnyItemFilter::getUIML() const
{
    return UIMLBuilder::createAnyItemFilter()->build();
}

AnyItemFilterFactory::AnyItemFilterFactory()
    : SubTypeFactory()
{}

AnyItemFilter* AnyItemFilterFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    return new AnyItemFilter();
}

Framework::JSON::JSONObject* AnyItemFilterFactory::toJsonObject(
    AnyItemFilter* zObject) const
{
    return new Framework::JSON::JSONObject();
}

JSONObjectValidationBuilder* AnyItemFilterFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder;
}

const char* AnyItemFilterFactory::getTypeToken() const
{
    return "anyItem";
}

TypeItemFilter::TypeItemFilter()
    : ItemFilter(),
      type(0)
{}

bool TypeItemFilter::matchItem(const Item* zItem) const
{
    return zItem->zItemType() == type;
}

UIMLItemFilterBuilder* TypeItemFilter::getUIML() const
{
    return UIMLBuilder::createItemAttributeFilter()
        ->requireAttributeEquals("Type", Framework::Text() += type->getId())
        ->itemTypeIcon(type->getId())
        ->build();
}

void TypeItemFilter::setType(const ItemType* type)
{
    this->type = type;
}

const ItemType* TypeItemFilter::zType() const
{
    return type;
}

TypeItemFilterFactory::TypeItemFilterFactory()
    : SubTypeFactory()
{}

TypeItemFilter* TypeItemFilterFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    TypeItemFilter* result = new TypeItemFilter();
    result->setType(Game::INSTANCE->zItemType(Game::INSTANCE->getItemTypeId(
        zJson->zValue("itemType")->asString()->getString())));
    return result;
}

Framework::JSON::JSONObject* TypeItemFilterFactory::toJsonObject(
    TypeItemFilter* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue("itemType",
        new Framework::JSON::JSONString(zObject->zType()->getName()));
    return result;
}

JSONObjectValidationBuilder* TypeItemFilterFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredAttribute("itemType",
        Game::INSTANCE->zTypeRegistry()->getValidator<Framework::Text>(
            ItemTypeNameFactory::TYPE_ID));
}

const char* TypeItemFilterFactory::getTypeToken() const
{
    return "type";
}

SpecificSlotFilter::SpecificSlotFilter(int sourceSlotId, int targetSlotId)
    : ItemFilter(),
      sourceSlotId(sourceSlotId),
      targetSlotId(targetSlotId)
{}

bool SpecificSlotFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    return sourceSlotId == zSlot->getId();
}

bool SpecificSlotFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    return targetSlotId == zSlot->getId();
}

UIMLItemFilterBuilder* SpecificSlotFilter::getUIML() const
{
    return UIMLBuilder::createAnyItemFilter()->build();
}

SourceSlotBlacklistFilter::SourceSlotBlacklistFilter()
    : ItemFilter()
{}

void SourceSlotBlacklistFilter::addBlackListSlotId(int id)
{
    blackList.add(id);
}

bool SourceSlotBlacklistFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    for (int black : blackList)
    {
        if (black == zSlot->getId()) return 0;
    }
    return 1;
}

bool SourceSlotBlacklistFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    return 1;
}

UIMLItemFilterBuilder* SourceSlotBlacklistFilter::getUIML() const
{
    return UIMLBuilder::createAnyItemFilter()->build();
}

TargetSlotBlacklistFilter::TargetSlotBlacklistFilter()
    : ItemFilter()
{}

void TargetSlotBlacklistFilter::addBlackListSlotId(int id)
{
    blackList.add(id);
}

bool TargetSlotBlacklistFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    return 1;
}

bool TargetSlotBlacklistFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    for (int black : blackList)
    {
        if (black == zSlot->getId()) return 0;
    }
    return 1;
}

UIMLItemFilterBuilder* TargetSlotBlacklistFilter::getUIML() const
{
    return UIMLBuilder::createAnyItemFilter()->build();
}

GroupItemFilter::GroupItemFilter()
    : ItemFilter()
{}

bool GroupItemFilter::matchItem(const Item* zItem) const
{
    for (Framework::Text* group : groups)
    {
        for (Framework::Text* typeGroup : zItem->zItemType()->getGroups())
        {
            if (typeGroup->isEqual(*group)) return true;
        }
    }
    return false;
}

UIMLItemFilterBuilder* GroupItemFilter::getUIML() const
{
    CombinedItemFilter filter;
    for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
    {
        if (Game::INSTANCE->zItemType(i))
        {
            bool found = false;
            for (Framework::Text* group : groups)
            {
                for (Framework::Text* typeGroup :
                    Game::INSTANCE->zItemType(i)->getGroups())
                {
                    if (typeGroup->isEqual(*group))
                    {
                        found = true;
                        break;
                    }
                }
                if (found) break;
            }
            if (found)
            {
                TypeItemFilter* f = new TypeItemFilter();
                f->setType(Game::INSTANCE->zItemType(i));
                filter.addFilter(f);
            }
        }
    }
    filter.setOp([](bool a, bool b) { return a || b; });
    return filter.getUIML();
}

void GroupItemFilter::addGroup(const Framework::Text group)
{
    groups.add(new Framework::Text(group));
}

const Framework::RCArray<Framework::Text>& GroupItemFilter::getGroups() const
{
    return groups;
}

GroupItemFilterFactory::GroupItemFilterFactory()
    : SubTypeFactory()
{}

GroupItemFilter* GroupItemFilterFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    GroupItemFilter* result = new GroupItemFilter();
    for (Framework::JSON::JSONValue* group :
        *zJson->zValue("groupNames")->asArray())
    {
        result->addGroup(group->asString()->getString());
    }
    return result;
}

Framework::JSON::JSONObject* GroupItemFilterFactory::toJsonObject(
    GroupItemFilter* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    Framework::JSON::JSONArray* groups = new Framework::JSON::JSONArray();
    for (Framework::Text* group : zObject->getGroups())
    {
        groups->addValue(new Framework::JSON::JSONString(group->getText()));
    }
    result->addValue("groupNames", groups);
    return result;
}

JSONObjectValidationBuilder* GroupItemFilterFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredArray("groupNames")
        ->addAcceptedStringInArray()
        ->finishString()
        ->finishArray();
}

const char* GroupItemFilterFactory::getTypeToken() const
{
    return "groups";
}

TargetSlotNameItemFilter::TargetSlotNameItemFilter(
    const Framework::Text& slotName)
    : ItemFilter(),
      slotName(slotName)
{}

bool TargetSlotNameItemFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    return 1;
}

bool TargetSlotNameItemFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    return zSlot->getName().isEqual(slotName);
}

UIMLItemFilterBuilder* TargetSlotNameItemFilter::getUIML() const
{
    return UIMLBuilder::createAnyItemFilter()->build();
}

SourceSlotNameItemFilter::SourceSlotNameItemFilter(
    const Framework::Text& slotName)
    : ItemFilter(),
      slotName(slotName)
{}

bool SourceSlotNameItemFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    return zSlot->getName().isEqual(slotName);
}

bool SourceSlotNameItemFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    return 1;
}

UIMLItemFilterBuilder* SourceSlotNameItemFilter::getUIML() const
{
    return UIMLBuilder::createAnyItemFilter()->build();
}