FactoryCraft-Server/FactoryCraft/BlockType.cpp

#include "BlockType.h"
#include "ItemType.h"
#include "BasicBlocks.h"
#include "Block.h"

using namespace Framework;

BlockType::BlockType(int id, Block* defaultBlock,
	ModelInfo model, bool needsClientInstance, int initialMaxHP)
	: ReferenceCounter(),
	id(id),
	model(model),
	needsClientInstance(needsClientInstance),
	initialMaxHP(initialMaxHP),
	defaultBlock(defaultBlock)
{
	StaticRegistry<BlockType>::INSTANCE.registerT(this, id);
}

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

void BlockType::loadSuperBlock(Block* zBlock, Framework::StreamReader* zReader) const
{
	zBlock->loadInventory(zReader);
	zReader->lese((char*)&zBlock->transparent, 1);
	zReader->lese((char*)&zBlock->passable, 1);
	zReader->lese((char*)&zBlock->hp, 4);
	zReader->lese((char*)&zBlock->maxHP, 4);
	zReader->lese((char*)&zBlock->hardness, 4);
	zReader->lese((char*)&zBlock->speedModifier, 4);
	int effectiveToolId;
	zReader->lese((char*)&effectiveToolId, 4);
	if (effectiveToolId >= 0)
		zBlock->zTool = StaticRegistry<ItemType>::INSTANCE.zElement(effectiveToolId);
	else
		zBlock->zTool = 0;
}

void BlockType::saveSuperBlock(Block* zBlock, Framework::StreamWriter* zWriter) const
{
	zBlock->saveInventory(zWriter);
	zWriter->schreibe((char*)&zBlock->transparent, 1);
	zWriter->schreibe((char*)&zBlock->passable, 1);
	zWriter->schreibe((char*)&zBlock->hp, 4);
	zWriter->schreibe((char*)&zBlock->maxHP, 4);
	zWriter->schreibe((char*)&zBlock->hardness, 4);
	zWriter->schreibe((char*)&zBlock->speedModifier, 4);
	int effectiveToolId = zBlock->zTool ? zBlock->zTool->getId() : -1;
	zWriter->schreibe((char*)&effectiveToolId, 4);
}

void BlockType::createSuperBlock(Block* zBlock, Item* zItem) const
{
	BasicBlockItem* item = dynamic_cast<BasicBlockItem*>(zItem);
	if (!item)
	{
		throw "BlockType::createSuperBlock was called with an item witch was not an instance of BasicBlockItem";
	}
	zBlock->transparent = item->transparent;
	zBlock->passable = item->passable;
	zBlock->hp = item->hp;
	zBlock->maxHP = item->maxHP;
	zBlock->hardness = item->hardness;
	zBlock->speedModifier = item->speedModifier;
	zBlock->zTool = item->toolId >= 0 ? StaticRegistry<ItemType>::INSTANCE.zElement(item->toolId) : 0;
	zBlock->interactable = item->interactable;
}

void BlockType::createSuperItem(Block* zBlock, Item* zItem) const
{
	BasicBlockItem* item = dynamic_cast<BasicBlockItem*>(zItem);
	if (!item)
	{
		throw "BlockType::createSuperItem was called with an item witch was not an instance of BasicBlockItem";
	}
	item->transparent = zBlock->transparent;
	item->passable = zBlock->passable;
	item->hp = zBlock->maxHP; // reset hp
	item->maxHP = zBlock->maxHP;
	item->hardness = zBlock->hardness;
	item->speedModifier = zBlock->speedModifier;
	item->toolId = zBlock->zTool ? zBlock->zTool->getId() : -1;
	item->interactable = zBlock->interactable;
}

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

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

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

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

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

const ModelInfo& BlockType::getModel() const
{
	return model;
}

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

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

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


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