FactoryCraft-Server/FactoryCraft/BlockFilter.cpp

#include "BlockFilter.h"

#include "Block.h"
#include "FluidBlock.h"
#include "Game.h"

BlockFilter::BlockFilter()
    : ReferenceCounter()
{}

BlockFilterAnd::BlockFilterAnd(Framework::RCArray<BlockFilter> filters)
    : BlockFilter(),
      filters(filters)
{}

bool BlockFilterAnd::test(const Block* zBlock)
{
    for (BlockFilter* filter : filters)
    {
        if (!filter->test(zBlock))
        {
            return false;
        }
    }
    return true;
}

Framework::RCArray<BlockFilter> BlockFilterAnd::getFilters() const
{
    return filters;
}

BlockFilterAndFactory::BlockFilterAndFactory()
    : SubTypeFactory()
{}

BlockFilterAnd* BlockFilterAndFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    Framework::RCArray<BlockFilter> filters;
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("filters")->asArray())
    {
        filters.add(
            Game::INSTANCE->zTypeRegistry()->fromJson<BlockFilter>(value));
    }
    return new BlockFilterAnd(filters);
}

Framework::JSON::JSONObject* BlockFilterAndFactory::toJson(
    BlockFilterAnd* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    Framework::JSON::JSONArray* filters = new Framework::JSON::JSONArray();
    for (BlockFilter* filter : zObject->getFilters())
    {
        filters->addValue(Game::INSTANCE->zTypeRegistry()->toJson(filter));
    }
    result->addValue("filters", filters);
    return result;
}

Framework::JSON::Validator::JSONValidator* BlockFilterAndFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder->withRequiredArray("filters")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<BlockFilter>())
        ->finishArray()
        ->finishObject();
}

Framework::Text BlockFilterAndFactory::getTypeToken() const
{
    return "and";
}

BlockFilterOr::BlockFilterOr(Framework::RCArray<BlockFilter> filters)
    : BlockFilter(),
      filters(filters)
{}

bool BlockFilterOr::test(const Block* zBlock)
{
    for (BlockFilter* filter : filters)
    {
        if (filter->test(zBlock))
        {
            return true;
        }
    }
    return false;
}

Framework::RCArray<BlockFilter> BlockFilterOr::getFilters() const
{
    return filters;
}

BlockFilterOrFactory::BlockFilterOrFactory()
    : SubTypeFactory()
{}

BlockFilterOr* BlockFilterOrFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    Framework::RCArray<BlockFilter> filters;
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("filters")->asArray())
    {
        filters.add(
            Game::INSTANCE->zTypeRegistry()->fromJson<BlockFilter>(value));
    }
    return new BlockFilterOr(filters);
}

Framework::JSON::JSONObject* BlockFilterOrFactory::toJson(
    BlockFilterOr* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    Framework::JSON::JSONArray* filters = new Framework::JSON::JSONArray();
    for (BlockFilter* filter : zObject->getFilters())
    {
        filters->addValue(Game::INSTANCE->zTypeRegistry()->toJson(filter));
    }
    result->addValue("filters", filters);
    return result;
}

Framework::JSON::Validator::JSONValidator* BlockFilterOrFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder->withRequiredArray("filters")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<BlockFilter>())
        ->finishArray()
        ->finishObject();
}

Framework::Text BlockFilterOrFactory::getTypeToken() const
{
    return "or";
}

BlockFilterNot::BlockFilterNot(BlockFilter* filter)
    : BlockFilter(),
      filter(filter)
{}

bool BlockFilterNot::test(const Block* zBlock)
{
    return !filter->test(zBlock);
}

BlockFilter* BlockFilterNot::zFilter() const
{
    return filter;
}

BlockFilterNotFactory::BlockFilterNotFactory()
    : SubTypeFactory()
{}

BlockFilterNot* BlockFilterNotFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterNot(
        Game::INSTANCE->zTypeRegistry()->fromJson<BlockFilter>(
            zJson->zValue("filter")));
}

Framework::JSON::JSONObject* BlockFilterNotFactory::toJson(
    BlockFilterNot* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue(
        "filter", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zFilter()));
    return result;
}

Framework::JSON::Validator::JSONValidator* BlockFilterNotFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder
        ->withRequiredAttribute("filter",
            Game::INSTANCE->zTypeRegistry()->getValidator<BlockFilter>())
        ->finishObject();
}

Framework::Text BlockFilterNotFactory::getTypeToken() const
{
    return "not";
}

BlockFilterBlockType::BlockFilterBlockType(Framework::Array<int> blockTypeIds)
    : BlockFilter(),
      blockTypeIds(blockTypeIds)
{}

bool BlockFilterBlockType::test(const Block* zBlock)
{
    for (int blockTypeId : blockTypeIds)
    {
        if (zBlock->zBlockType()->getId() == blockTypeId)
        {
            return true;
        }
    }
    return false;
}

const Framework::Array<int>& BlockFilterBlockType::getBlockTypeIds() const
{
    return blockTypeIds;
}

BlockFilterBlockTypeFactory::BlockFilterBlockTypeFactory()
    : SubTypeFactory()
{}

BlockFilterBlockType* BlockFilterBlockTypeFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    Framework::Array<int> blockTypeIds;
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("typeNames")->asArray())
    {
        blockTypeIds.add(
            Game::INSTANCE->getBlockTypeId(value->asString()->getString()));
    }
    return new BlockFilterBlockType(blockTypeIds);
}

Framework::JSON::JSONObject* BlockFilterBlockTypeFactory::toJson(
    BlockFilterBlockType* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    Framework::JSON::JSONArray* typeNames = new Framework::JSON::JSONArray();
    for (int typeId : zObject->getBlockTypeIds())
    {
        typeNames->addValue(new Framework::JSON::JSONString(
            Game::INSTANCE->zBlockType(typeId)->getName()));
    }
    result->addValue("typeNames", typeNames);
    return result;
}

Framework::JSON::Validator::JSONValidator*
BlockFilterBlockTypeFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder->withRequiredArray("typeNames")
        ->addAcceptedStringInArray()
        ->finishString()
        ->finishArray()
        ->finishObject();
}

Framework::Text BlockFilterBlockTypeFactory::getTypeToken() const
{
    return "types";
}

BlockFilterTypeGroup::BlockFilterTypeGroup(
    Framework::RCArray<Framework::Text> groupNames)
    : BlockFilter(),
      groupNames(groupNames)
{}

bool BlockFilterTypeGroup::test(const Block* zBlock)
{
    for (Framework::Text* groupName : groupNames)
    {
        for (Framework::Text* otherGroupName :
            zBlock->zBlockType()->getGroupNames())
        {
            if (groupName->istGleich(*otherGroupName))
            {
                return true;
            }
        }
    }
    return false;
}

const Framework::RCArray<Framework::Text>&
BlockFilterTypeGroup::getGroupNames() const
{
    return groupNames;
}

BlockFilterTypeGroupFactory::BlockFilterTypeGroupFactory()
    : SubTypeFactory()
{}

BlockFilterTypeGroup* BlockFilterTypeGroupFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    Framework::RCArray<Framework::Text> groupNames;
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("groupNames")->asArray())
    {
        groupNames.add(new Framework::Text(value->asString()->getString()));
    }
    return new BlockFilterTypeGroup(groupNames);
}

Framework::JSON::JSONObject* BlockFilterTypeGroupFactory::toJson(
    BlockFilterTypeGroup* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    Framework::JSON::JSONArray* groupNames = new Framework::JSON::JSONArray();
    for (Framework::Text* groupName : zObject->getGroupNames())
    {
        groupNames->addValue(new Framework::JSON::JSONString(*groupName));
    }
    result->addValue("groupNames", groupNames);
    return result;
}

Framework::JSON::Validator::JSONValidator*
BlockFilterTypeGroupFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder->withRequiredArray("groupNames")
        ->addAcceptedStringInArray()
        ->finishString()
        ->finishArray()
        ->finishObject();
}

Framework::Text BlockFilterTypeGroupFactory::getTypeToken() const
{
    return "groups";
}

BlockFilterMaxHardness::BlockFilterMaxHardness(float maxHardness)
    : BlockFilter(),
      maxHardness(maxHardness)
{}

bool BlockFilterMaxHardness::test(const Block* zBlock)
{
    return zBlock->zBlockType()->getHardness() <= maxHardness;
}

float BlockFilterMaxHardness::getMaxHardness() const
{
    return maxHardness;
}

BlockFilterMaxHardnessFactory::BlockFilterMaxHardnessFactory()
    : SubTypeFactory()
{}

BlockFilterMaxHardness* BlockFilterMaxHardnessFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterMaxHardness(
        (float)zJson->zValue("maxHardness")->asNumber()->getNumber());
}

Framework::JSON::JSONObject* BlockFilterMaxHardnessFactory::toJson(
    BlockFilterMaxHardness* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue("maxHardness",
        new Framework::JSON::JSONNumber(zObject->getMaxHardness()));
    return result;
}

Framework::JSON::Validator::JSONValidator*
BlockFilterMaxHardnessFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder->withRequiredNumber("maxHardness")
        ->whichIsGreaterOrEqual(0.0)
        ->finishNumber()
        ->finishObject();
}

Framework::Text BlockFilterMaxHardnessFactory::getTypeToken() const
{
    return "maxHardness";
}

BlockFilterMinHardness::BlockFilterMinHardness(float minHardness)
    : BlockFilter(),
      minHardness(minHardness)
{}

bool BlockFilterMinHardness::test(const Block* zBlock)
{
    return zBlock->zBlockType()->getHardness() >= minHardness;
}

float BlockFilterMinHardness::getMinHardness() const
{
    return minHardness;
}

BlockFilterMinHardnessFactory::BlockFilterMinHardnessFactory()
    : SubTypeFactory()
{}

BlockFilterMinHardness* BlockFilterMinHardnessFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterMinHardness(
        (float)zJson->zValue("minHardness")->asNumber()->getNumber());
}

Framework::JSON::JSONObject* BlockFilterMinHardnessFactory::toJson(
    BlockFilterMinHardness* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue("minHardness",
        new Framework::JSON::JSONNumber(zObject->getMinHardness()));
    return result;
}

Framework::JSON::Validator::JSONValidator*
BlockFilterMinHardnessFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder->withRequiredNumber("minHardness")
        ->whichIsGreaterOrEqual(0.0)
        ->finishNumber()
        ->finishObject();
}

Framework::Text BlockFilterMinHardnessFactory::getTypeToken() const
{
    return "minHardness";
}

BlockFilterMaxHeat::BlockFilterMaxHeat(float maxHeat)
    : BlockFilter(),
      maxHeat(maxHeat)
{}

bool BlockFilterMaxHeat::test(const Block* zBlock)
{
    const FluidBlockType* type
        = dynamic_cast<const FluidBlockType*>(zBlock->zBlockType());
    return type && type->getHeat() <= maxHeat;
}

float BlockFilterMaxHeat::getMaxHeat() const
{
    return maxHeat;
}

BlockFilterMaxHeatFactory::BlockFilterMaxHeatFactory()
    : SubTypeFactory()
{}

BlockFilterMaxHeat* BlockFilterMaxHeatFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterMaxHeat(
        (float)zJson->zValue("heat")->asNumber()->getNumber());
}

Framework::JSON::JSONObject* BlockFilterMaxHeatFactory::toJson(
    BlockFilterMaxHeat* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue(
        "heat", new Framework::JSON::JSONNumber(zObject->getMaxHeat()));
    return result;
}

Framework::JSON::Validator::JSONValidator*
BlockFilterMaxHeatFactory::getValidator(
    Framework::JSON::Validator::ObjectValidationBuilder<
        Framework::JSON::Validator::JSONValidator>* builder) const
{
    return builder->withRequiredNumber("heat")->finishNumber()->finishObject();
}

Framework::Text BlockFilterMaxHeatFactory::getTypeToken() const
{
    return "maxHeat";
}