FactoryCraft-Server/FactoryCraft/Recipie.cpp

#include "Recipie.h"

#include <Logging.h>

#include "CraftingStorage.h"
#include "Game.h"
#include "Item.h"
#include "ItemType.h"
#include "UIMLBuilder.h"

RecipieInput::RecipieInput()
    : ReferenceCounter(),
      filter(0),
      modifier(0),
      amount(0)
{}

RecipieInput::~RecipieInput()
{
    if (filter) filter->release();
    if (modifier) modifier->release();
}

void RecipieInput::setFilter(ItemFilter* filter)
{
    if (this->filter) this->filter->release();
    this->filter = filter;
}

ItemFilter* RecipieInput::zFilter() const
{
    return filter;
}

void RecipieInput::setModifier(ItemModifier* modifier)
{
    if (this->modifier) this->modifier->release();
    this->modifier = modifier;
}

ItemModifier* RecipieInput::zModifier() const
{
    return modifier;
}

void RecipieInput::setAmount(int amount)
{
    this->amount = amount;
}

int RecipieInput::getAmount() const
{
    return amount;
}

RecipieInputFactory::RecipieInputFactory()
    : ObjectTypeFactory()
{}

RecipieInput* RecipieInputFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    RecipieInput* result = new RecipieInput();
    result->setFilter(Game::INSTANCE->zTypeRegistry()->fromJson<ItemFilter>(
        zJson->asObject()->zValue("filter")));
    result->setModifier(Game::INSTANCE->zTypeRegistry()->fromJson<ItemModifier>(
        zJson->asObject()->zValue("modifier")));
    result->setAmount(
        (int)zJson->asObject()->zValue("amount")->asNumber()->getNumber());
    return result;
}

Framework::JSON::JSONObject* RecipieInputFactory::toJsonObject(
    RecipieInput* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue(
        "filter", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zFilter()));
    result->addValue("modifier",
        Game::INSTANCE->zTypeRegistry()->toJson(zObject->zModifier()));
    result->addValue("amount",
        new Framework::JSON::JSONNumber((double)zObject->getAmount()));
    return result;
}

JSONObjectValidationBuilder* RecipieInputFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    Framework::JSON::JSONObject* defaultModifier
        = new Framework::JSON::JSONObject();
    defaultModifier->addValue(
        "type", new Framework::JSON::JSONString("consume"));
    return builder
        ->withRequiredAttribute("filter",
            Game::INSTANCE->zTypeRegistry()->getValidator<ItemFilter>())
        ->withRequiredAttribute("modifier",
            Game::INSTANCE->zTypeRegistry()->getValidator<ItemModifier>())
        ->withRequiredObject("modifier")
        ->withRequiredString("type")
        ->withExactMatch("consume")
        ->finishString()
        ->withDefault(defaultModifier)
        ->finishObject()
        ->withRequiredNumber("amount")
        ->whichIsGreaterOrEqual(1.0)
        ->withDefault(1.0)
        ->finishNumber();
}

RecipieOutput::RecipieOutput()
    : ReferenceCounter(),
      itemTypeId(0),
      amount(0),
      modifier(0)
{}

RecipieOutput::~RecipieOutput()
{
    modifier->release();
}

void RecipieOutput::setItemTypeId(int itemTypeId)
{
    this->itemTypeId = itemTypeId;
}

int RecipieOutput::getItemTypeId() const
{
    return itemTypeId;
}

void RecipieOutput::setAmount(int amount)
{
    this->amount = amount;
}

int RecipieOutput::getAmount() const
{
    return amount;
}

void RecipieOutput::setModifier(ItemModifier* modifier)
{
    if (this->modifier) this->modifier->release();
    this->modifier = modifier;
}

ItemModifier* RecipieOutput::zModifier() const
{
    return modifier;
}

Item* RecipieOutput::createItem() const
{
    Item* result = Game::INSTANCE->zItemType(itemTypeId)->createItem();
    if (result)
    {
        modifier->applyOn(result);
    }
    return result;
}

RecipieOutputFactory::RecipieOutputFactory()
    : ObjectTypeFactory()
{}

RecipieOutput* RecipieOutputFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    RecipieOutput* result = new RecipieOutput();
    result->setItemTypeId(Game::INSTANCE->getItemTypeId(
        zJson->asObject()->zValue("itemType")->asString()->getString()));
    result->setAmount(
        (int)zJson->asObject()->zValue("amount")->asNumber()->getNumber());
    result->setModifier(Game::INSTANCE->zTypeRegistry()->fromJson<ItemModifier>(
        zJson->asObject()->zValue("modifier")));
    return result;
}

Framework::JSON::JSONObject* RecipieOutputFactory::toJsonObject(
    RecipieOutput* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue("itemType",
        new Framework::JSON::JSONString(
            Game::INSTANCE->zItemType(zObject->getItemTypeId())->getName()));
    result->addValue("amount",
        new Framework::JSON::JSONNumber((double)zObject->getAmount()));
    result->addValue("modifier",
        Game::INSTANCE->zTypeRegistry()->toJson(zObject->zModifier()));
    return result;
}

JSONObjectValidationBuilder* RecipieOutputFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    Framework::JSON::JSONObject* defaultModifier
        = new Framework::JSON::JSONObject();
    defaultModifier->addValue(
        "type", new Framework::JSON::JSONString("doNothing"));
    return builder
        ->withRequiredAttribute("itemType",
            Game::INSTANCE->zTypeRegistry()->getValidator<Framework::Text>(
                ItemTypeNameFactory::TYPE_ID))
        ->withRequiredAttribute("modifier",
            Game::INSTANCE->zTypeRegistry()->getValidator<ItemModifier>())
        ->withRequiredObject("modifier")
        ->withRequiredString("type")
        ->withExactMatch("doNothing")
        ->finishString()
        ->withDefault(defaultModifier)
        ->finishObject()
        ->withRequiredNumber("amount")
        ->whichIsGreaterOrEqual(1.0)
        ->withDefault(1.0)
        ->finishNumber();
}

Recipie::Recipie()
    : ReferenceCounter()
{}

void Recipie::apply(CraftingStorage* zStorage)
{
    consumeInputs(zStorage);
    produceOutputs(zStorage);
}

void Recipie::addOutput(RecipieOutput* outputs)
{
    this->outputs.add(outputs);
}

Framework::Array<ItemInfo> Recipie::getOutput() const
{
    Framework::Array<ItemInfo> result;
    for (const RecipieOutput* output : outputs)
    {
        Item* item = output->createItem();
        if (item)
        {
            result.add({item->zItemType()->getId(),
                output->getAmount(),
                item->getHp(),
                item->getMaxHp(),
                item->getDurability(),
                item->getMaxDurability()});
            item->release();
        }
    }
    return result;
}

bool Recipie::createsOutput(int itemTypeId)
{
    for (RecipieOutput* output : outputs)
    {
        if (output->getItemTypeId() == itemTypeId)
        {
            return 1;
        }
    }
    return 0;
}

void Recipie::setGroupName(Framework::Text groupName)
{
    this->groupName = groupName;
}

const Framework::RCArray<RecipieOutput>& Recipie::getOutputs() const
{
    return outputs;
}

Framework::Text Recipie::getGroupName() const
{
    return groupName;
}

int Recipie::getTicksNeeded() const
{
    return 1;
}

int Recipie::getFuelPerTickNeeded() const
{
    return 0;
}

UnshapedRecipie::UnshapedRecipie()
    : Recipie()
{}

bool UnshapedRecipie::testApplicability(CraftingStorage* zStorage)
{
    for (RecipieOutput* output : outputs)
    {
        Item* item = output->createItem();
        if (item)
        {
            if (!zStorage->hasFreeSpace(item, output->getAmount()))
            {
                item->release();
                return 0;
            }
            item->release();
        }
    }
    return zStorage->isAllAvailable(inputs);
}

void UnshapedRecipie::consumeInputs(CraftingStorage* zStorage)
{
    zStorage->consume(inputs);
}

void UnshapedRecipie::produceOutputs(CraftingStorage* zStorage)
{
    for (RecipieOutput* output : outputs)
    {
        Item* item = output->createItem();
        if (item)
        {
            ItemStack* stack = new ItemStack(item, output->getAmount());
            zStorage->addCraftingResult(stack);
            if (stack->getSize() > 0)
            {
                Game::INSTANCE->spawnItem(zStorage->getStorageLocation(),
                    zStorage->getStorageDimensionId(),
                    stack);
            }
            else
            {
                stack->release();
            }
        }
    }
}

Framework::XML::Element* UnshapedRecipie::getRecipieUIML() const
{
    UIMLUnshapedRecipieBuilder* builder = UIMLBuilder::createUnshapedRecipie();
    for (RecipieInput* input : inputs)
    {
        builder->addIngredient(UIMLBuilder::createRecipieIngredient()
                ->setAmount(input->getAmount())
                ->setFilter(input->zFilter()->getUIML()));
        // TODO: add modifiers
    }
    for (RecipieOutput* output : outputs)
    {
        Item* item = output->createItem();
        if (item)
        {
            builder->addOutput(UIMLBuilder::createRecipieOutput()
                    ->setAmount(output->getAmount())
                    ->setItemTypeID(item->zItemType()->getId())
                    ->setHP(item->getHp())
                    ->setDurability(item->getDurability())
                    ->setMaxHP(item->getMaxHp())
                    ->setMaxDurability(item->getMaxDurability())
                    ->setToolTip(item->getTooltipUIML()));
            item->release();
        }
    }
    return builder->build();
}

void UnshapedRecipie::addInput(RecipieInput* input)
{
    inputs.add(input);
}

const Framework::RCArray<RecipieInput>& UnshapedRecipie::getInputs() const
{
    return inputs;
}

ShapedRecipie::ShapedRecipie()
    : Recipie(),
      width(0),
      height(0)
{}

bool ShapedRecipie::testApplicability(CraftingStorage* zStorage)
{
    ShapedCraftingStorage* zShapedStorage
        = dynamic_cast<ShapedCraftingStorage*>(zStorage);
    if (!zShapedStorage) return 0;
    for (RecipieOutput* output : outputs)
    {
        Item* item = output->createItem();
        if (item)
        {
            if (!zShapedStorage->hasFreeSpace(item, output->getAmount()))
            {
                item->release();
                return 0;
            }
            item->release();
        }
    }
    return zShapedStorage->isAllAvailable(inputs, width, height);
}

void ShapedRecipie::consumeInputs(CraftingStorage* zStorage)
{
    ShapedCraftingStorage* zShapedStorage
        = dynamic_cast<ShapedCraftingStorage*>(zStorage);
    zShapedStorage->consume(inputs, width, height);
}

void ShapedRecipie::produceOutputs(CraftingStorage* zStorage)
{
    for (RecipieOutput* output : outputs)
    {
        Item* item = output->createItem();
        if (item)
        {
            ItemStack* stack = new ItemStack(item, output->getAmount());
            zStorage->addCraftingResult(stack);
            if (stack->getSize() > 0)
            {
                Game::INSTANCE->spawnItem(zStorage->getStorageLocation(),
                    zStorage->getStorageDimensionId(),
                    stack);
            }
            else
            {
                stack->release();
            }
        }
    }
}

Framework::XML::Element* ShapedRecipie::getRecipieUIML() const
{
    UIMLShapedRecipieBuilder* builder
        = UIMLBuilder::createShapedRecipie()->setWidth(width)->setHeight(
            height);
    for (RecipieInput* input : inputs)
    {
        builder->addIngredient(UIMLBuilder::createRecipieIngredient()
                ->setAmount(input->getAmount())
                ->setFilter(input->zFilter()->getUIML()));
        // TODO: add modifiers
    }
    for (RecipieOutput* output : outputs)
    {
        Item* item = output->createItem();
        if (item)
        {
            builder->addOutput(UIMLBuilder::createRecipieOutput()
                    ->setAmount(output->getAmount())
                    ->setItemTypeID(item->zItemType()->getId())
                    ->setHP(item->getHp())
                    ->setDurability(item->getDurability())
                    ->setMaxHP(item->getMaxHp())
                    ->setMaxDurability(item->getMaxDurability())
                    ->setToolTip(item->getTooltipUIML()));
            item->release();
        }
    }
    return builder->build();
}

void ShapedRecipie::setWidth(int width)
{
    this->width = width;
}

int ShapedRecipie::getWidth() const
{
    return width;
}

void ShapedRecipie::setHeight(int height)
{
    this->height = height;
}

int ShapedRecipie::getHeight() const
{
    return height;
}

void ShapedRecipie::addInput(RecipieInput* input)
{
    inputs.add(input);
}

void ShapedRecipie::setInput(int index, RecipieInput* input)
{
    inputs.set(input, index);
}

const Framework::RCArray<RecipieInput>& ShapedRecipie::getInputs() const
{
    return inputs;
}

ShapedRecipieFactory::ShapedRecipieFactory()
    : RecipieFactory()
{}

ShapedRecipie* ShapedRecipieFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new ShapedRecipie();
}

ShapedRecipie* ShapedRecipieFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    ShapedRecipie* result = RecipieFactory::fromJson(zJson);
    int width = (int)zJson->zValue("width")->asNumber()->getNumber();
    int height = (int)zJson->zValue("height")->asNumber()->getNumber();
    for (int i = 0; i < width * height; i++)
    {
        result->addInput(new RecipieInput());
    }
    for (Framework::JSON::JSONValue* input :
        *zJson->zValue("inputs")->asArray())
    {
        int x = (int)input->asObject()->zValue("x")->asNumber()->getNumber();
        int y = (int)input->asObject()->zValue("y")->asNumber()->getNumber();
        if (x >= width || y >= height)
        {
            Framework::Logging::warning()
                << "Invalid input position in shaped recipie with width="
                << width << ", height=" << height << ", x=" << x << ", y=" << y
                << " input " << input->toString() << " will be ignored.";
            continue;
        }
        result->setInput(y * width + x,
            Game::INSTANCE->zTypeRegistry()->fromJson<RecipieInput>(
                input->asObject()->zValue("input")));
    }
    result->setWidth((int)zJson->zValue("width")->asNumber()->getNumber());
    result->setHeight((int)zJson->zValue("height")->asNumber()->getNumber());
    return result;
}

Framework::JSON::JSONObject* ShapedRecipieFactory::toJsonObject(
    ShapedRecipie* zObject) const
{
    Framework::JSON::JSONObject* result = RecipieFactory::toJsonObject(zObject);
    result->addValue(
        "width", new Framework::JSON::JSONNumber(zObject->getWidth()));
    result->addValue(
        "height", new Framework::JSON::JSONNumber(zObject->getHeight()));
    Framework::JSON::JSONArray* inputs = new Framework::JSON::JSONArray();
    for (int i = 0; i < zObject->getWidth() * zObject->getHeight(); i++)
    {
        Framework::JSON::JSONObject* input = new Framework::JSON::JSONObject();
        input->addValue(
            "x", new Framework::JSON::JSONNumber(i % zObject->getHeight()));
        input->addValue(
            "y", new Framework::JSON::JSONNumber(i / zObject->getHeight()));
        input->addValue("input",
            Game::INSTANCE->zTypeRegistry()->toJson(zObject->getInputs().z(i)));
        inputs->addValue(input);
    }
    result->addValue("inputs", inputs);
    return result;
}

JSONObjectValidationBuilder* ShapedRecipieFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return RecipieFactory::addToValidator(builder->withRequiredArray("inputs")
            ->addAcceptedObjectInArray()
            ->withRequiredNumber("x")
            ->whichIsGreaterOrEqual(0.0)
            ->finishNumber()
            ->withRequiredNumber("y")
            ->whichIsGreaterOrEqual(0.0)
            ->finishNumber()
            ->withRequiredAttribute("input",
                Game::INSTANCE->zTypeRegistry()->getValidator<RecipieInput>())
            ->finishObject()
            ->finishArray()
            ->withRequiredNumber("width")
            ->whichIsGreaterOrEqual(1.0)
            ->finishNumber()
            ->withRequiredNumber("height")
            ->whichIsGreaterOrEqual(1.0)
            ->finishNumber());
}

const char* ShapedRecipieFactory::getTypeToken() const
{
    return "shaped";
}

MachineRecipie::MachineRecipie()
    : UnshapedRecipie(),
      neededTicks(1),
      neededFuelPerTick(0)
{}

void MachineRecipie::setTicksNeeded(int ticks)
{
    neededTicks = ticks;
}

int MachineRecipie::getTicksNeeded() const
{
    return neededTicks;
}

void MachineRecipie::setFuelPerTickNeeded(int fuel)
{
    neededFuelPerTick = fuel;
}

int MachineRecipie::getFuelPerTickNeeded() const
{
    return neededFuelPerTick;
}

MachineRecipieFactory::MachineRecipieFactory()
    : UnshapedRecipieFactory()
{}

MachineRecipie* MachineRecipieFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new MachineRecipie();
}

MachineRecipie* MachineRecipieFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    MachineRecipie* result = UnshapedRecipieFactory::fromJson(zJson);
    result->setTicksNeeded(
        (int)zJson->zValue("ticksNeeded")->asNumber()->getNumber());
    result->setFuelPerTickNeeded(
        (int)zJson->zValue("fuelPerTickNeeded")->asNumber()->getNumber());
    return result;
}

Framework::JSON::JSONObject* MachineRecipieFactory::toJsonObject(
    MachineRecipie* zObject) const
{
    Framework::JSON::JSONObject* result
        = UnshapedRecipieFactory::toJsonObject(zObject);
    result->addValue("ticksNeeded",
        new Framework::JSON::JSONNumber(zObject->getTicksNeeded()));
    result->addValue("fuelPerTickNeeded",
        new Framework::JSON::JSONNumber(zObject->getFuelPerTickNeeded()));
    return result;
}

JSONObjectValidationBuilder* MachineRecipieFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return UnshapedRecipieFactory::addToValidator(builder)
        ->withRequiredNumber("ticksNeeded")
        ->whichIsGreaterOrEqual(1.0)
        ->withDefault(1.0)
        ->finishNumber()
        ->withRequiredNumber("fuelPerTickNeeded")
        ->whichIsGreaterOrEqual(0.0)
        ->withDefault(0.0)
        ->finishNumber();
}

const char* MachineRecipieFactory::getTypeToken() const
{
    return "machine";
}