FactoryCraft-Server/FactoryCraft/ItemType.h

#pragma once

#include <JSON.h>
#include <Text.h>
#include <Writer.h>

#include "BlockType.h"
#include "Game.h"
#include "ModelInfo.h"

class Item;
class ItemStack;
class ItemSkill;
class ItemSkillLevelUpRule;

class ItemTypeEnum
{
public:
    static const int PLAYER_HAND = 0;
};

class ItemType : public virtual Framework::ReferenceCounter
{
protected:
    int id;
    Framework::Text name;
    Framework::XML::Element* tooltipUIML;
    ModelInfo* model;
    int maxStackSize;
    Framework::RCArray<Framework::Text> groups;

public:
    ItemType();
    virtual ~ItemType();

protected:
    virtual void loadSuperItem(
        Item* zItem, Framework::StreamReader* zReader) const;
    virtual void saveSuperItem(
        const Item* zItem, Framework::StreamWriter* zWriter) const;

public:
    virtual bool initialize(Game* zGame);
    virtual const ItemType* zBrokenItemType() const;

    virtual Item* createItem() const = 0;

    virtual ItemStack* createItemStack(int size) const;
    virtual ItemSkill* createDefaultItemSkill() const;
    virtual void levelUpItemSkill(ItemSkill* zSkill) const;
    virtual Item* cloneItem(const Item* zItem) const;
    virtual Item* breakItem(const Item* zItem) const;

    virtual Item* loadItem(Framework::StreamReader* zReader) const;
    virtual void saveItem(
        const Item* zItem, Framework::StreamWriter* zWriter) const;

    virtual void setItemAttribute(Item* zItem,
        Framework::Text name,
        Framework::JSON::JSONValue* zValue) const;
    virtual void addItemAttributes(
        Item* zItem, Framework::JSON::JSONObject* zItemObjet) const;

    void setTypeId(int id);
    int getId() const;
    void setName(Framework::Text name);
    const Framework::Text& getName() const;
    void setTooltipUIML(Framework::Text tooltipUIML);
    Framework::XML::Element* getTooltipUIML() const;
    void setModel(ModelInfo* model);
    ModelInfo* zModel() const;
    void setMaxStackSize(int maxStackSize);
    int getMaxStackSize() const;
    void addGroup(Framework::Text group);
    const Framework::RCArray<Framework::Text>& getGroups() const;

    static Item* createBasicItem(int id,
        const char* name,
        float hp,
        float maxHp,
        float durability,
        float maxDurability,
        bool eatable,
        bool placeable,
        bool equippable,
        bool solid,
        bool usable);
    static int getTypeId(const char* name);
    static const ItemType* zByName(const char* name);
};

template<typename S> class ItemTypeFactoryBase
    : public SubTypeFactory<ItemType, S>
{
public:
    ItemTypeFactoryBase()
        : SubTypeFactory<ItemType, S>()
    {}

    virtual S* fromJson(Framework::JSON::JSONObject* zJson) const override
    {
        S* result = createValue(zJson);
        ItemType* zType = dynamic_cast<ItemType*>(result);
        zType->setModel(Game::INSTANCE->zTypeRegistry()->fromJson<ModelInfo>(
            zJson->zValue("model")->asObject()));
        zType->setName(zJson->zValue("name")->asString()->getString());
        if (zJson->hasValue("tooltipUIML"))
        {
            zType->setTooltipUIML(
                zJson->zValue("tooltipUIML")->asString()->getString());
        }
        zType->setMaxStackSize(
            (int)zJson->zValue("maxStack")->asNumber()->getNumber());
        for (Framework::JSON::JSONValue* value :
            *zJson->zValue("groupNames")->asArray())
        {
            zType->addGroup(value->asString()->getString());
        }
        return result;
    }

    virtual Framework::JSON::JSONObject* toJsonObject(S* zObject) const
    {
        Framework::JSON::JSONObject* zResult
            = new Framework::JSON::JSONObject();
        ItemType* zType = dynamic_cast<ItemType*>(zObject);
        zResult->addValue("model",
            Game::INSTANCE->zTypeRegistry()->toJson<ModelInfo>(
                zType->zModel()));
        zResult->addValue(
            "name", new Framework::JSON::JSONString(zType->getName()));
        Framework::XML::Element* tooltipUIML = zType->getTooltipUIML();
        zResult->addValue("tooltipUIML",
            new Framework::JSON::JSONString(tooltipUIML->toString()));
        tooltipUIML->release();
        zResult->addValue("maxStack",
            new Framework::JSON::JSONNumber(zType->getMaxStackSize()));
        Framework::JSON::JSONArray* groupNames
            = new Framework::JSON::JSONArray();
        for (Framework::Text* groupName : zType->getGroups())
        {
            groupNames->addValue(new Framework::JSON::JSONString(*groupName));
        }
        zResult->addValue("groupNames", groupNames);
        return zResult;
    }

    virtual JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override
    {
        return builder
            ->withRequiredAttribute("model",
                Game::INSTANCE->zTypeRegistry()->getValidator<ModelInfo>())
            ->withRequiredString("name")
            ->finishString()
            ->withOptionalString("tooltipUIML")
            ->finishString()
            ->withRequiredNumber("maxStack")
            ->withDefault(50)
            ->finishNumber()
            ->withRequiredArray("groupNames")
            ->withDefault(new Framework::JSON::JSONArray())
            ->addAcceptedStringInArray()
            ->finishString()
            ->finishArray();
    }

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