FactoryCraft-Server/FactoryCraft/Block.cpp

#include "Block.h"
#include "Inventory.h"

Block::Block( const BlockType *zType, ItemType *zTool, Framework::Vec3<int> pos, bool hasInventory )
    : Inventory( pos, hasInventory )
{
    transparent = false;
    passable = false;
    hp = 1;
    maxHP = 1;
    hardness = 1;
    this->zType = zType;
    this->zTool = zTool;
    speedModifier = 1;
    ticksLeftCounter = 0;
    wasTicked = 0;
    onTickCalled = 0;
    minTickTimeout = -1;
    maxTickTimeout = -1;
    tickSource = 0;
    currentTickTimeout = 0;
    dimansionId = 0;
    memset( zNeighbours, 0, sizeof( Block * ) * 6 );
}

Block::~Block()
{}

void Block::tick( TickQueue *zQueue )
{
    if( wasTicked )
        return;
    wasTicked = 1;
    ticksLeftCounter++;
    if( minTickTimeout >= 0 )
    {
        if( currentTickTimeout < ticksLeftCounter )
        {
            onTickCalled = 1;
            bool blocked = 0;
            bool result = onTick( zQueue, ticksLeftCounter, blocked );
            if( blocked )
            {
                wasTicked = 0;
                ticksLeftCounter--;
                onTickCalled = 0;
                return;
            }
            if( result )
                currentTickTimeout = MAX( MIN( currentTickTimeout - 1, maxTickTimeout ), MAX( minTickTimeout, 0 ) );
            else
                currentTickTimeout = MAX( MIN( currentTickTimeout + 1, maxTickTimeout ), MAX( minTickTimeout, 0 ) );
            ticksLeftCounter = 0;
        }
    }
}

void Block::postTick()
{
    wasTicked = 0;
    if( onTickCalled )
    {
        onPostTick();
        onTickCalled = 0;
    }
}

void Block::setNeighbour( Direction dir, Block *zN )
{
    zNeighbours[ getDirectionIndex( dir ) ] = zN;
}

void Block::setDimensionId( int id )
{
    dimansionId = id;
}

void api( Framework::StreamReader *zRequest, NetworkResponse *zResponse )
{
    // TODO: answer api requests
}

bool Block::isTickSource() const
{
    return tickSource;
}

const BlockType *Block::zBlockType() const
{
    return zType;
}

bool Block::isTransparent() const
{
    return transparent;
}

bool Block::isPassable() const
{
    return passable;
}

float Block::getHP() const
{
    return hp;
}

float Block::getMaxHP() const
{
    return maxHP;
}

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

ItemType *Block::zEffectiveTool() const
{
    return zTool;
}

float Block::getSpeedModifier() const
{
    return speedModifier;
}

const Framework::Vec3<int> Block::getPos() const
{
    return location;
}

int Block::getDimensionId() const
{
    return dimansionId;
}

bool Block::isVisible() const
{
    for( int i = 0; i < 6; i++ )
    {
        if( zNeighbours[ i ] == (Block*)AIR_BLOCK || (IS_BLOCK( zNeighbours[ i ] ) && zNeighbours[ i ]->isTransparent()))
            return 1;
    }
    return 0;
}


BasicBlockItem::BasicBlockItem( const ItemType *zType, const char *name )
    : Item( zType, name )
{
    placeable = 1;
}

bool BasicBlockItem::canBeStackedWith( Item *zItem ) const
{
    BasicBlockItem *item = dynamic_cast<BasicBlockItem *>( zItem );
    if( item )
    {
        return Item::canBeStackedWith( zItem ) &&
            transparent == item->transparent &&
            passable == item->passable &&
            hp == item->hp &&
            maxHP == item->maxHP &&
            hardness == item->hardness &&
            toolId == item->toolId &&
            speedModifier == item->speedModifier;
    }
    return 0;
}


BasicBlockItemType::BasicBlockItemType( int id, ItemSkillLevelUpRule *levelUpRule, const ItemType *zBrokenType )
    : ItemType( id, levelUpRule, zBrokenType )
{}

void BasicBlockItemType::loadSuperItem( Item *zItem, Framework::StreamReader *zReader ) const
{
    ItemType::loadSuperItem( zItem, zReader );
    BasicBlockItem *item = dynamic_cast<BasicBlockItem *>( zItem );
    if( !item )
        throw "BasicBlockItemType::loadSuperItem was called with an invalid item";
    zReader->lese( (char *)&item->transparent, 1 );
    zReader->lese( (char *)&item->passable, 1 );
    zReader->lese( (char *)&item->hp, 4 );
    zReader->lese( (char *)&item->maxHP, 4 );
    zReader->lese( (char *)&item->hardness, 4 );
    zReader->lese( (char *)&item->toolId, 4 );
    zReader->lese( (char *)&item->speedModifier, 4 );
}

void BasicBlockItemType::saveSuperItem( const Item *zItem, Framework::StreamWriter *zWriter ) const
{
    ItemType::saveSuperItem( zItem, zWriter );
    const BasicBlockItem *item = dynamic_cast<const BasicBlockItem *>( zItem );
    if( !item )
        throw "BasicBlockItemType::saveSuperItem was called with an invalid item";
    zWriter->schreibe( (char *)&item->transparent, 1 );
    zWriter->schreibe( (char *)&item->passable, 1 );
    zWriter->schreibe( (char *)&item->hp, 4 );
    zWriter->schreibe( (char *)&item->maxHP, 4 );
    zWriter->schreibe( (char *)&item->hardness, 4 );
    zWriter->schreibe( (char *)&item->toolId, 4 );
    zWriter->schreibe( (char *)&item->speedModifier, 4 );
}

void BasicBlockItemType::initializeItem( BasicBlockItem *zItem, bool transparent, bool passable, float hp, float maxHP, float hardness, int toolId, float speedModifier ) const
{
    zItem->transparent = transparent;
    zItem->passable = passable;
    zItem->hp = hp;
    zItem->maxHP = maxHP;
    zItem->hardness = hardness;
    zItem->toolId = toolId;
    zItem->speedModifier = speedModifier;
}