FactoryCraft-Server/FactoryCraft/Block.h

#pragma once

#include <Vec3.h>

#include "Inventory.h"
#include "Item.h"
#include "ItemType.h"
#include "MultiblockStructure.h"
#include "NetworkMessage.h"
#include "Tickable.h"
#include "TickSourceType.h"

#define CONST_BLOCK(maybeBlock, type) \
    ((maybeBlock) ? (maybeBlock)      \
                  : Game::INSTANCE->zBlockType((int)(type))->zDefault())

class ItemType;
class Chunk;
class BasicBlockItemType;
class PlaceableProof;

class TickQueue;

class Block : public Inventory,
              public Tickable
{
private:
    int ticksLeftCounter;
    int currentTickTimeout;
    bool wasTicked;
    bool onTickCalled;

protected:
    Direction frontDirection;
    bool transparent;
    bool passable;
    float hp;
    float maxHP;
    float hardness;
    int typeId;
    float speedModifier;

    int minTickTimeout;
    int maxTickTimeout;
    bool interactable;
    bool transmissionRequested;
    bool deadAndRemoved;
    unsigned char lightEmisionColor[3];
    int mapColor;

    Framework::RCArray<MultiblockStructure> structures;

    /// <summary>
    /// executes block specific things
    /// </summary>
    /// <param name="zqueue">a queue to add neighbor blocks that should be
    /// ticked after this block</param> <param name="numTicks">the number of
    /// ticks passed since the last call (only for tickSources)</param> <param
    /// name="blocked">can be set to one to tell that this block needs to be
    /// tickt again later in the queue of this tick</param> <returns>true, iff
    /// the block needs to be ticked more often</returns>
    virtual bool onTick(TickQueue* zQueue, int numTicks, bool& blocked) = 0;
    /// <summary>
    /// gets called after each block was tickt.
    /// the order of blocks called will be exactly the same as onTick
    /// </summary>
    virtual void onPostTick() = 0;
    virtual void onDestroy(
        Entity* zActor, Item* zUsedItem, ItemSkill* zUsedSkill);

    virtual void onDialogClosed(Framework::Text dialogId);
    void broadcastModelInfoChange();
    void broadcastMessage(NetworkMessage* message);
    void broadcastPassableSpeedModifierChange();
    virtual void onApiCall(char messageType,
        Framework::StreamReader* zRequest,
        NetworkMessage* zResponse,
        Entity* zSource);

public:
    Block(int typeId,
        Framework::Vec3<int> pos,
        int dimensionId,
        bool hasInventory);
    Block(int typeId,
        Framework::Vec3<int> pos,
        int dimensionId,
        bool hasInventory,
        Direction frontDirection);
    virtual ~Block();

    void tick(TickQueue* zQueue) override;
    void postTick() override;
    void addToStructure(MultiblockStructure* structure);
    virtual void onLoaded();
    virtual void onUnloaded();
    virtual Framework::XML::Element* getTargetUIML() const;
    virtual void sendModelInfo(NetworkMessage* zMessage);
    virtual bool interact(Item* zItem, Entity* zActor, bool& itemChanged);
    void api(Framework::StreamReader* zRequest,
        NetworkMessage* zResponse,
        Entity* zSource);
    virtual TickSourceType isTickSource() const;
    virtual bool needsTick() const;
    const BlockType* zBlockType() const;
    bool isTransparent() const;
    bool isPassable() const;
    virtual bool isInteractable(const Item* zItem) const;
    float getHP() const;
    float getMaxHP() const;
    float getHardness() const;
    float getSpeedModifier() const;
    const Framework::Vec3<int> getPos() const;
    void setHP(
        Entity* zActor, Item* zUsedItem, ItemSkill* zUsedSkill, float hp);
    bool isDeadAndRemoved() const;
    virtual void getLightEmisionColor(unsigned char* result) const;
    virtual void filterPassingLight(unsigned char rgb[3]) const;
    void updateModel(ModelInfo* zInfo) const;
    int getMapColor() const;
    void setFrontDirection(Direction frontDirection);
    Direction getFrontDirection() const;

    friend BlockType;
};

class BasicBlockItem : public Item
{
protected:
    bool transparent;
    bool passable;
    float hardness;
    float speedModifier;
    bool interactable;
    PlaceableProof* placeableProof;

public:
    BasicBlockItem(int itemTypeId,
        int blockTypeId,
        Framework::Text name,
        PlaceableProof* placeableProof);
    ~BasicBlockItem();
    virtual bool canBeStackedWith(const Item* zItem) const override;
    virtual bool canBePlacedAt(
        int dimensionId, Framework::Vec3<int> worldPos) const override;

    friend BasicBlockItemType;
    friend BlockType;
};

class BasicBlockItemType : public ItemType
{
private:
    bool transparent;
    bool passable;
    float hardness;
    float speedModifier;
    Framework::Text blockTypeName;
    int blockTypeId;
    PlaceableProof* placeableProof;

public:
    BasicBlockItemType();
    BasicBlockItemType(Framework::Text name,
        ModelInfo* model,
        bool transparent,
        bool passable,
        float hardness,
        float speedModifier,
        Framework::Text blockTypeName,
        PlaceableProof* placeableProof,
        int maxStackSize,
        Framework::RCArray<Framework::Text> groups);
    ~BasicBlockItemType();

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

public:
    virtual bool initialize(Game* zGame) override;
    int getBlockTypeId() const;
    void setTransparent(bool transparent);
    bool isTransparent() const;
    void setPassable(bool passable);
    bool isPassable() const;
    void setHardness(float hardness);
    float getHardness() const;
    void setSpeedModifier(float speedModifier);
    float getSpeedModifier() const;
    void setBlockTypeName(Framework::Text blockTypeName);
    Framework::Text getBlockTypeName() const;
    void setPlaceableProof(PlaceableProof* placeableProof);
    PlaceableProof* zPlaceableProof() const;
};

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