FactoryCraft-Server/FactoryCraft/Recipie.h

#pragma once
#include <Array.h>
#include <JSON.h>

#include "Game.h"
#include "ItemFilter.h"
#include "ItemModifier.h"
#include "TypeRegistry.h"

class CraftingStorage;
class ShapedCraftingStorage;

struct ItemInfo
{
    int type;
    int count;
    float hp;
    float maxHp;
    float durability;
    float maxDurability;
};

class RecipieInput : public Framework::ReferenceCounter
{
private:
    ItemFilter* filter;
    ItemModifier* modifier;
    int amount;

public:
    RecipieInput();
    ~RecipieInput();
    void setFilter(ItemFilter* filter);
    ItemFilter* zFilter() const;
    void setModifier(ItemModifier* modifier);
    ItemModifier* zModifier() const;
    void setAmount(int amount);
    int getAmount() const;
};

class RecipieInputFactory : public ObjectTypeFactory<RecipieInput>
{
public:
    RecipieInputFactory();
    RecipieInput* fromJson(Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        RecipieInput* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
};

class RecipieOutput : public Framework::ReferenceCounter
{
private:
    int itemTypeId;
    int amount;
    ItemModifier* modifier;

public:
    RecipieOutput();
    ~RecipieOutput();
    void setItemTypeId(int itemTypeId);
    int getItemTypeId() const;
    void setAmount(int amount);
    int getAmount() const;
    void setModifier(ItemModifier* modifier);
    ItemModifier* zModifier() const;
    Item* createItem() const;
};

class RecipieOutputFactory : public ObjectTypeFactory<RecipieOutput>
{
public:
    RecipieOutputFactory();
    RecipieOutput* fromJson(Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        RecipieOutput* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
};

class Recipie : public virtual Framework::ReferenceCounter
{
protected:
    Framework::Text groupName;
    Framework::RCArray<RecipieOutput> outputs;

public:
    Recipie();
    virtual bool testApplicability(CraftingStorage* zStorage) = 0;
    virtual void consumeInputs(CraftingStorage* zStorage) = 0;
    virtual void produceOutputs(CraftingStorage* zStorage) = 0;
    virtual void apply(CraftingStorage* zStorage);
    virtual Framework::XML::Element* getRecipieUIML() const = 0;
    void addOutput(RecipieOutput* outputs);
    virtual Framework::Array<ItemInfo> getOutput() const;
    bool createsOutput(int itemTypeId);
    void setGroupName(Framework::Text groupName);
    const Framework::RCArray<RecipieOutput>& getOutputs() const;
    Framework::Text getGroupName() const;
    virtual int getTicksNeeded() const;
    virtual int getFuelPerTickNeeded() const;
};

template<typename S> class RecipieFactory : public SubTypeFactory<Recipie, S>
{
public:
    RecipieFactory()
        : SubTypeFactory<Recipie, S>()
    {}

    S* fromJson(Framework::JSON::JSONObject* zJson) const override
    {
        S* result = createValue(zJson);
        Recipie* zRecipie = dynamic_cast<Recipie*>(result);
        for (Framework::JSON::JSONValue* output :
            *zJson->zValue("outputs")->asArray())
        {
            zRecipie->addOutput(
                Game::INSTANCE->zTypeRegistry()->fromJson<RecipieOutput>(
                    output));
        }
        zRecipie->setGroupName(zJson->zValue("group")->asString()->getString());
        return result;
    }

    Framework::JSON::JSONObject* toJsonObject(S* zObject) const override
    {
        Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
        Recipie* zRecipie = dynamic_cast<Recipie*>(result);
        Framework::JSON::JSONArray* outputs = new Framework::JSON::JSONArray();
        for (RecipieOutput* output : zRecipie->getOutputs())
        {
            outputs->addValue(Game::INSTANCE->zTypeRegistry()->toJson(output));
        }
        result->addValue("outputs", outputs);
        result->addValue(
            "group", new Framework::JSON::JSONString(zRecipie->getGroupName()));
        return result;
    };

    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override
    {
        return builder->withRequiredArray("outputs")
            ->addAcceptedTypeInArray(
                Game::INSTANCE->zTypeRegistry()->getValidator<RecipieOutput>())
            ->finishArray()
            ->withRequiredString("group")
            ->finishString();
    }

protected:
    virtual S* createValue(Framework::JSON::JSONObject* zJson) const = 0;
};

class UnshapedRecipie : public Recipie
{
private:
    Framework::RCArray<RecipieInput> inputs;

public:
    UnshapedRecipie();
    bool testApplicability(CraftingStorage* zStorage) override;
    void consumeInputs(CraftingStorage* zStorage) override;
    void produceOutputs(CraftingStorage* zStorage) override;
    Framework::XML::Element* getRecipieUIML() const override;
    void addInput(RecipieInput* input);
    const Framework::RCArray<RecipieInput>& getInputs() const;
};

template<class T,
    typename = std::enable_if<std::is_base_of<UnshapedRecipie, T>::value>>
class UnshapedRecipieFactory : public RecipieFactory<T>
{
public:
    UnshapedRecipieFactory()
        : RecipieFactory<T>()
    {}

    T* createValue(Framework::JSON::JSONObject* zJson) const override
    {
        return (T*)new UnshapedRecipie();
    }

    T* fromJson(Framework::JSON::JSONObject* zJson) const override
    {
        UnshapedRecipie* result = dynamic_cast<UnshapedRecipie*>(
            RecipieFactory<T>::fromJson(zJson));
        for (Framework::JSON::JSONValue* input :
            *zJson->zValue("inputs")->asArray())
        {
            result->addInput(
                Game::INSTANCE->zTypeRegistry()->fromJson<RecipieInput>(input));
        }
        return dynamic_cast<T*>(result);
    }

    Framework::JSON::JSONObject* toJsonObject(T* zObject) const override
    {
        Framework::JSON::JSONObject* result
            = RecipieFactory<T>::toJsonObject(zObject);
        Framework::JSON::JSONArray* inputs = new Framework::JSON::JSONArray();
        for (RecipieInput* input : zObject->getInputs())
        {
            inputs->addValue(Game::INSTANCE->zTypeRegistry()->toJson(input));
        }
        result->addValue("inputs", inputs);
        return result;
    }

    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override
    {
        return RecipieFactory<T>::addToValidator(
            builder->withRequiredArray("inputs")
                ->addAcceptedTypeInArray(Game::INSTANCE->zTypeRegistry()
                        ->getValidator<RecipieInput>())
                ->finishArray());
    }

    const char* getTypeToken() const override
    {
        return "unshaped";
    }
};

class ShapedRecipie : public Recipie
{
private:
    Framework::RCArray<RecipieInput> inputs;
    int width;
    int height;

public:
    ShapedRecipie();
    bool testApplicability(CraftingStorage* zStorage) override;
    void consumeInputs(CraftingStorage* zStorage) override;
    void produceOutputs(CraftingStorage* zStorage) override;
    Framework::XML::Element* getRecipieUIML() const override;
    void setWidth(int width);
    int getWidth() const;
    void setHeight(int height);
    int getHeight() const;
    void addInput(RecipieInput* input);
    void setInput(int index, RecipieInput* input);
    const Framework::RCArray<RecipieInput>& getInputs() const;
};

class ShapedRecipieFactory : public RecipieFactory<ShapedRecipie>
{
public:
    ShapedRecipieFactory();
    ShapedRecipie* createValue(
        Framework::JSON::JSONObject* zJson) const override;
    ShapedRecipie* fromJson(Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        ShapedRecipie* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class MachineRecipie : public UnshapedRecipie
{
private:
    int neededTicks;
    int neededFuelPerTick;

public:
    MachineRecipie();
    void setTicksNeeded(int ticks);
    virtual int getTicksNeeded() const override;
    void setFuelPerTickNeeded(int fuel);
    virtual int getFuelPerTickNeeded() const override;
};

class MachineRecipieFactory : public UnshapedRecipieFactory<MachineRecipie>
{
public:
    MachineRecipieFactory();
    MachineRecipie* createValue(
        Framework::JSON::JSONObject* zJson) const override;
    MachineRecipie* fromJson(Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        MachineRecipie* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};