FactoryCraft-Server/FactoryCraft/BlockType.cpp

#include "BlockType.h"

#include "Block.h"
#include "Dimension.h"
#include "Game.h"
#include "MultiblockStructure.h"
#include "UIMLBuilder.h"

using namespace Framework;

BlockType::BlockType()
    : ReferenceCounter(),
      id(0),
      model(0),
      initialMaxHP(0),
      needsClientInstance(true),
      lightSource(false),
      needModelSubscription(false),
      initialMapColor(0),
      hardness(1.f),
      damagableByHand(0),
      itemType(0),
      defaultFrontDirection(Direction::NORTH),
      defaultBlock(0)
{}

BlockType::~BlockType()
{
    if (model) model->release();
    if (defaultBlock) defaultBlock->release();
}

void BlockType::loadSuperBlock(
    Block* zBlock, Framework::StreamReader* zReader, int dimensionId) const
{
    zBlock->loadInventory(zReader);
    zReader->read((char*)&zBlock->transparent, 1);
    zReader->read((char*)&zBlock->passable, 1);
    zReader->read((char*)&zBlock->hp, 4);
    zReader->read((char*)&zBlock->maxHP, 4);
    zReader->read((char*)&zBlock->hardness, 4);
    zReader->read((char*)&zBlock->speedModifier, 4);
    zReader->read((char*)&zBlock->mapColor, 4);
    zReader->read((char*)&zBlock->interactable, 1);
    zReader->read((char*)&zBlock->frontDirection, 1);
    int strCount;
    zReader->read((char*)&strCount, 4);
    for (int i = 0; i < strCount; i++)
    {
        __int64 id;
        zReader->read((char*)&id, 8);
        MultiblockStructure* str
            = Game::INSTANCE->zDimension(dimensionId)->zStructureById(id);
        if (str)
        {
            zBlock->structures.add(
                dynamic_cast<MultiblockStructure*>(str->getThis()));
        }
    }
}

void BlockType::saveSuperBlock(
    Block* zBlock, Framework::StreamWriter* zWriter) const
{
    zBlock->saveInventory(zWriter);
    zWriter->write((char*)&zBlock->transparent, 1);
    zWriter->write((char*)&zBlock->passable, 1);
    zWriter->write((char*)&zBlock->hp, 4);
    zWriter->write((char*)&zBlock->maxHP, 4);
    zWriter->write((char*)&zBlock->hardness, 4);
    zWriter->write((char*)&zBlock->speedModifier, 4);
    zWriter->write((char*)&zBlock->mapColor, 4);
    zWriter->write((char*)&zBlock->interactable, 1);
    zWriter->write((char*)&zBlock->frontDirection, 1);
    int strCount = zBlock->structures.getEntryCount();
    zWriter->write((char*)&strCount, 4);
    for (MultiblockStructure* structure : zBlock->structures)
    {
        __int64 id = structure->getStructureId();
        zWriter->write((char*)&id, 8);
    }
}

void BlockType::createSuperBlock(Block* zBlock, Item* zItem) const
{
    if (zItem)
    {
        BasicBlockItem* item = dynamic_cast<BasicBlockItem*>(zItem);
        if (item)
        {
            zBlock->transparent = item->transparent;
            zBlock->passable = item->passable;
            zBlock->hardness = item->hardness;
            zBlock->speedModifier = item->speedModifier;
            zBlock->interactable = item->interactable;
        }
    }
    zBlock->mapColor = initialMapColor;
    zBlock->frontDirection = defaultFrontDirection;
}

void BlockType::createSuperItem(Block* zBlock, Item* zItem) const
{
    BasicBlockItem* item = dynamic_cast<BasicBlockItem*>(zItem);
    if (item)
    {
        item->transparent = zBlock->transparent;
        item->passable = zBlock->passable;
        item->hardness = zBlock->hardness;
        item->speedModifier = zBlock->speedModifier;
        item->interactable = zBlock->interactable;
    }
}

bool BlockType::initialize(Game* zGame)
{
    for (DropConfig* config : dropConfigs)
    {
        config->initialize();
    }
    return true;
}

BlockType* BlockType::initializeDefault()
{
    if (!defaultBlock)
    {
        defaultBlock = createBlockAt({0, 0, 0}, 0, 0);
    }
    return this;
}

void BlockType::addDropConfig(DropConfig* config)
{
    dropConfigs.add(config);
}

const Framework::RCArray<DropConfig>& BlockType::getDropConfigs() const
{
    return dropConfigs;
}

const Block* BlockType::zDefault() const
{
    return defaultBlock;
}

ItemType* BlockType::createItemType()
{
    ItemType* result = createItemTypeInternal();
    itemType = result;
    return result;
}

int BlockType::getItemTypeId() const
{
    return itemType ? itemType->getId() : -1;
}

void BlockType::writeTypeInfo(StreamWriter* zWriter) const
{
    int id = getId();
    zWriter->write((char*)&id, 4);
    bool inst = doesNeedClientInstance();
    zWriter->write((char*)&inst, 1);
    bool sub = doesNeedModelSubscription();
    zWriter->write((char*)&sub, 1);
    bool fluid = isFluid();
    zWriter->write((char*)&fluid, 1);
    if (fluid)
    {
        char flowDist = getFlowDistance();
        zWriter->write(&flowDist, 1);
    }
    zWriter->write((char*)&defaultFrontDirection, 1);
    int maxHp = getInitialMaxHP();
    zWriter->write((char*)&maxHp, 4);
    zModel()->writeTo(zWriter);
}

Framework::XML::Element* BlockType::getTargetUIML() const
{
    return UIMLBuilder::createContainer()
        ->addChild(UIMLBuilder::createTextAuto(name)->setID("type")->build())
        ->build();
}

Block* BlockType::loadBlock(Framework::Vec3<int> position,
    Framework::StreamReader* zReader,
    int dimensionId) const
{
    Block* result = createBlockAt(position, dimensionId, 0);
    loadSuperBlock(result, zReader, dimensionId);
    return result;
}

void BlockType::saveBlock(Block* zBlock, Framework::StreamWriter* zWriter) const
{
    saveSuperBlock(zBlock, zWriter);
}

Item* BlockType::getItemFromBlock(Block* zBlock) const
{
    Item* result = createItem();
    if (result)
    {
        createSuperItem(zBlock, result);
    }
    return result;
}

Block* BlockType::createBlockAt(
    Framework::Vec3<int> position, int dimensionId, Item* zUsedItem) const
{
    Block* result = createBlock(position, dimensionId);
    createSuperBlock(result, zUsedItem);
    return result;
}

int BlockType::getId() const
{
    return id;
}

bool BlockType::isFluid() const
{
    return false;
}

unsigned char BlockType::getFlowDistance() const
{
    return 0;
}

void BlockType::setTypeId(int id)
{
    this->id = id;
}

void BlockType::setModel(ModelInfo* model)
{
    this->model = model;
}

ModelInfo* BlockType::zModel() const
{
    return model;
}

void BlockType::setInitialMaxHP(int initialMaxHP)
{
    this->initialMaxHP = initialMaxHP;
}

int BlockType::getInitialMaxHP() const
{
    return initialMaxHP;
}

void BlockType::setNeedsClientInstance(bool needsClientInstance)
{
    this->needsClientInstance = needsClientInstance;
}

bool BlockType::doesNeedClientInstance() const
{
    return needsClientInstance;
}

void BlockType::setLightSource(bool lightSource)
{
    this->lightSource = lightSource;
}

bool BlockType::isLightSource() const
{
    return lightSource;
}

void BlockType::setName(Framework::Text name)
{
    this->name = name;
}

const char* BlockType::getName() const
{
    return name;
}

void BlockType::setNeedModelSubscription(bool needModelSubscription)
{
    this->needModelSubscription = needModelSubscription;
}

const bool BlockType::doesNeedModelSubscription() const
{
    return needModelSubscription;
}

void BlockType::setMapColor(int mapColor)
{
    this->initialMapColor = mapColor;
}

int BlockType::getMapColor() const
{
    return initialMapColor;
}

void BlockType::setGroupNames(Framework::RCArray<Framework::Text> groupNames)
{
    this->groupNames = groupNames;
}

const Framework::RCArray<Framework::Text>& BlockType::getGroupNames() const
{
    return groupNames;
}

void BlockType::setHardness(float hardness)
{
    this->hardness = hardness;
}

float BlockType::getHardness() const
{
    return hardness;
}

void BlockType::setDamagableByHand(bool damagableByHand)
{
    this->damagableByHand = damagableByHand;
}

bool BlockType::isDamagableByHand() const
{
    return damagableByHand;
}

void BlockType::addInteractionConfig(InteractionConfig* config)
{
    interactionConfigs.add(config);
}

const Framework::RCArray<InteractionConfig>&
BlockType::getInteractionConfigs() const
{
    return interactionConfigs;
}

void BlockType::setDefaultFrontDirection(Direction defaultFrontDirection)
{
    this->defaultFrontDirection = defaultFrontDirection;
}

Direction BlockType::getDefaultFrontDirection() const
{
    return defaultFrontDirection;
}

int BlockType::getTypeId(const char* name)
{
    Text n = name;
    for (int i = 0; i < Game::INSTANCE->getBlockTypeCount(); i++)
    {
        if (Game::INSTANCE->zBlockType(i)
            && n.isEqual(Game::INSTANCE->zBlockType(i)->getName()))
            return Game::INSTANCE->zBlockType(i)->getId();
    }
    return 0;
}

Framework::Text BlockType::getTypeName(int id)
{
    for (int i = 0; i < Game::INSTANCE->getBlockTypeCount(); i++)
    {
        if (Game::INSTANCE->zBlockType(i)
            && Game::INSTANCE->zBlockType(i)->getId() == id)
            return Game::INSTANCE->zBlockType(i)->getName();
    }
    return 0;
}

const Block* getDefaultBlock(Either<Block*, int> b)
{
    if (b.isA())
        return b;
    else
        return Game::INSTANCE->zBlockType(b)->zDefault();
}