FactoryCraft-Server/FactoryCraft/ItemFilter.cpp

#include "ItemFilter.h"

#include "Item.h"
#include "ItemSlot.h"
#include "ItemType.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* filterA,
    ItemFilter* filterB,
    std::function<bool(bool, bool)> op)
    : ItemFilter(),
      filterA(filterA),
      filterB(filterB),
      op(op)
{}

CombinedItemFilter::~CombinedItemFilter()
{
    filterA->release();
    filterB->release();
}

bool CombinedItemFilter::matchItem(const Item* zItem) const
{
    return op(filterA->matchItem(zItem), filterB->matchItem(zItem));
}

bool CombinedItemFilter::matchSourceSlot(ItemSlot* zSlot) const
{
    return op(filterA->matchSourceSlot(zSlot), filterB->matchSourceSlot(zSlot));
}

bool CombinedItemFilter::matchTargetSlot(ItemSlot* zSlot) const
{
    return op(filterA->matchTargetSlot(zSlot), filterB->matchTargetSlot(zSlot));
}

Framework::Text CombinedItemFilter::getLogicUIML() const
{
    Framework::Text result = "<operator result_0_0=\"";
    result += (int)op(0, 0);
    result += "\" result_0_1=\"";
    result += (int)op(0, 1);
    result += "\" result_1_0=\"";
    result += (int)op(1, 0);
    result += "\" result_1_1=\"";
    result += (int)op(1, 1);
    result += "\">";
    result += filterA->getLogicUIML();
    result += filterB->getLogicUIML();
    result += "</operator>";
    return result;
}


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

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

Framework::Text AnyItemFilter::getLogicUIML() const
{
    return "<anyItem/>";
}

TypeItemFilter::TypeItemFilter(const ItemType* zType)
    : ItemFilter(),
      zType(zType)
{}

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

Framework::Text TypeItemFilter::getLogicUIML() const
{
    Framework::Text result = "<attribute name=\"Type\" operator=\"=\" value=\"";
    result += zType->getId();
    result += "\"/>";
    return result;
}

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();
}

Framework::Text SpecificSlotFilter::getLogicUIML() const
{
    return "<anyItem/>";
}

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;
}

Framework::Text SourceSlotBlacklistFilter::getLogicUIML() const
{
    return "<anyItem/>";
}

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;
}

Framework::Text TargetSlotBlacklistFilter::getLogicUIML() const
{
    return "<anyItem/>";
}