FactoryCraft-Server/FactoryCraft/BasicBlocks.h

#pragma once

#include "Block.h"
#include "BlockType.h"
#include "Item.h"
#include "TypeRegistry.h"

class BlockType;
class ItemType;
class BasicBlockType;

class BasicBlock : public Block
{
public:
    BasicBlock(int typeId, Framework::Vec3<int> pos, int dimensionId);
    BasicBlock(int typeId,
        Framework::Vec3<int> pos,
        int dimensionId,
        bool hasInventory);
    virtual bool onTick(
        TickQueue* zQueue, int numTicks, bool& blocked) override;
    virtual void onPostTick() override;

    friend BasicBlockType;
};

class BasicBlockType : public BlockType
{
private:
    Framework::Text itemTypeName;
    int itemTypeId;
    bool transparent;
    bool passable;
    float speedModifier;
    bool interactable;
    Framework::RCArray<ItemSlot> itemSlots;

protected:
    virtual void createSuperBlock(Block* zBlock, Item* zItem) const override;

public:
    BasicBlockType();
    virtual bool initialize(Game* zGame) override;
    virtual Block* createBlock(
        Framework::Vec3<int> position, int dimensionId) const override;
    virtual Item* createItem() const override;
    Framework::Text getItemTypeName() const;
    virtual ItemType* createItemType() const override;
    void setItemTypeName(Framework::Text itemTypeName);
    int getItemTypeId() const;
    void setTransparent(bool transparent);
    bool isTransparent() const;
    void setPassable(bool passable);
    bool isPassable() const;
    void setSpeedModifier(float speedModifier);
    float getSpeedModifier() const;
    void setInteractable(bool interactable);
    bool isInteractable() const;
    const Framework::RCArray<ItemSlot>& getInventorySlots() const;
    void addInventorySlot(ItemSlot* slot);
};

template<class T,
    typename = std::enable_if<std::is_base_of<BasicBlockType, T>::value>>
class BasicBlockTypeFactory : public BlockTypeFactoryBase<T>
{
public:
    BasicBlockTypeFactory()
        : BlockTypeFactoryBase<T>()
    {}

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

    virtual T* fromJson(Framework::JSON::JSONObject* zJson) const override
    {
        T* result = BlockTypeFactoryBase<T>::fromJson(zJson);
        if (zJson->zValue("itemType")->getType()
            == Framework::AbstractType::STRING)
        {
            result->setItemTypeName(
                zJson->zValue("itemType")->asString()->getString());
        }
        else
        {
            result->setItemTypeName("");
        }
        result->setTransparent(
            zJson->zValue("transparent")->asBool()->getBool());
        result->setPassable(zJson->zValue("passable")->asBool()->getBool());
        result->setSpeedModifier(
            (float)zJson->zValue("speedModifier")->asNumber()->getNumber());
        result->setInteractable(
            (float)zJson->zValue("interactable")->asBool()->getBool());
        for (Framework::JSON::JSONValue* value :
            *zJson->zValue("inventorySlots")->asArray())
        {
            result->addInventorySlot(
                Game::INSTANCE->zTypeRegistry()->fromJson<ItemSlot>(
                    value->asObject()));
        }
        return result;
    }

    virtual Framework::JSON::JSONObject* toJsonObject(T* zObject) const override
    {
        Framework::JSON::JSONObject* result
            = BlockTypeFactoryBase<T>::toJsonObject(zObject);
        if (zObject->getItemTypeName().istGleich(""))
        {
            result->addValue("itemType", new Framework::JSON::JSONValue());
        }
        else
        {
            result->addValue("itemType",
                new Framework::JSON::JSONString(zObject->getItemTypeName()));
        }
        result->addValue("transparent",
            new Framework::JSON::JSONBool(zObject->isTransparent()));
        result->addValue(
            "passable", new Framework::JSON::JSONBool(zObject->isPassable()));
        result->addValue("speedModifier",
            new Framework::JSON::JSONNumber(zObject->getSpeedModifier()));
        result->addValue("interactable",
            new Framework::JSON::JSONBool(zObject->isInteractable()));
        Framework::JSON::JSONArray* inventorySlots
            = new Framework::JSON::JSONArray();
        for (ItemSlot* slot : zObject->getInventorySlots())
        {
            inventorySlots->addValue(
                Game::INSTANCE->zTypeRegistry()->toJson<ItemSlot>(slot));
        }
        result->addValue("inventorySlots", inventorySlots);
        return result;
    }

    virtual JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override
    {
        return BlockTypeFactoryBase<T>::addToValidator(
            builder
                ->withRequiredAttribute("itemType",
                    Game::INSTANCE->zTypeRegistry()
                        ->getValidator<Framework::Text>(
                            ItemTypeNameFactory::TYPE_ID),
                    true,
                    false)
                ->withRequiredBool("transparent")
                ->withDefault(false)
                ->finishBool()
                ->withRequiredBool("passable")
                ->withDefault(false)
                ->finishBool()
                ->withRequiredNumber("speedModifier")
                ->withDefault(1.0)
                ->finishNumber()
                ->withRequiredBool("interactable")
                ->withDefault(true)
                ->finishBool())
            ->withRequiredArray("inventorySlots")
            ->withDefault(new Framework::JSON::JSONArray())
            ->addAcceptedTypeInArray(
                Game::INSTANCE->zTypeRegistry()->getValidator<ItemSlot>())
            ->finishArray();
    }

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