FactoryCraft-Client/FactoryCraft/BasicBlocks.cpp

#include "BasicBlocks.h"
#include <Model3D.h>
#include <Globals.h>
#include <GraphicsApi.h>
#include <Bild.h>
#include <Model3DList.h>
#include "Globals.h"


BasicBlock::BasicBlock( const BlockType* zType, const char* texture, ItemType* zTool, Framework::Vec3<int> pos, Framework::Textur* t )
    : Block( zType, zTool, pos, false )
{
    Model3DData* data = 0;
    if( window->zBildschirm()->zGraphicsApi()->hasModel( "cube" ) )
        data = window->zBildschirm()->zGraphicsApi()->getModel( "cube" );
    else
    {
        data = window->zBildschirm()->zGraphicsApi()->createModel( "cube" );
        data->setAmbientFactor( 0.8f );
        data->setDiffusFactor( 0.1f );
        data->setSpecularFactor( 0.1f );
        float size = 1;
        float left, right, top, bottom;
        // Calculate the screen coordinates of the left side of the bitmap.
        left = (float)((size / 2.0) * -1);
        // Calculate the screen coordinates of the right side of the bitmap.
        right = left + (float)size;
        // Calculate the screen coordinates of the top of the bitmap.
        top = (float)(size / 2.0);
        // Calculate the screen coordinates of the bottom of the bitmap.
        bottom = top - (float)size;
        float front = -size / 2;
        float back = front + size;

        Vertex3D* vertecies = new Vertex3D[ 24 ];
        for( int i = 0; i < 24; i++ )
            vertecies[ i ].knochenId = 0;
        vertecies[ 0 ].pos = Vec3<float >( left, top, front );
        vertecies[ 0 ].tPos = Vec2< float >( 0.f, 0.f );
        vertecies[ 1 ].pos = Vec3<float >( right, top, front );
        vertecies[ 1 ].tPos = Vec2< float >( 1.f, 0.f );
        vertecies[ 2 ].pos = Vec3<float >( left, bottom, front );
        vertecies[ 2 ].tPos = Vec2< float >( 0.f, 1.f );
        vertecies[ 3 ].pos = Vec3<float >( right, bottom, front );
        vertecies[ 3 ].tPos = Vec2< float >( 1.f, 1.f );
        vertecies[ 4 ].pos = Vec3<float >( left, top, back );
        vertecies[ 4 ].tPos = Vec2< float >( 0.0f, 0.0f );
        vertecies[ 5 ].pos = Vec3<float >( right, top, back );
        vertecies[ 5 ].tPos = Vec2< float >( 1.0f, 0.0f );
        vertecies[ 6 ].pos = Vec3<float >( left, bottom, back );
        vertecies[ 6 ].tPos = Vec2< float >( 0.0f, 1.0f );
        vertecies[ 7 ].pos = Vec3<float >( right, bottom, back );
        vertecies[ 7 ].tPos = Vec2< float >( 1.0f, 1.0f );

        vertecies[ 8 ].pos = Vec3<float >( left, top, front );
        vertecies[ 8 ].tPos = Vec2< float >( 1.f, 0.f );
        vertecies[ 9 ].pos = Vec3<float >( right, top, front );
        vertecies[ 9 ].tPos = Vec2< float >( 0.f, 0.f );
        vertecies[ 10 ].pos = Vec3<float >( left, bottom, front );
        vertecies[ 10 ].tPos = Vec2< float >( 1.f, 1.f );
        vertecies[ 11 ].pos = Vec3<float >( right, bottom, front );
        vertecies[ 11 ].tPos = Vec2< float >( 0.f, 1.f );
        vertecies[ 12 ].pos = Vec3<float >( left, top, back );
        vertecies[ 12 ].tPos = Vec2< float >( 0.0f, 0.0f );
        vertecies[ 13 ].pos = Vec3<float >( right, top, back );
        vertecies[ 13 ].tPos = Vec2< float >( 1.0f, 0.0f );
        vertecies[ 14 ].pos = Vec3<float >( left, bottom, back );
        vertecies[ 14 ].tPos = Vec2< float >( 0.0f, 1.0f );
        vertecies[ 15 ].pos = Vec3<float >( right, bottom, back );
        vertecies[ 15 ].tPos = Vec2< float >( 1.0f, 1.0f );

        vertecies[ 16 ].pos = Vec3<float >( left, top, front );
        vertecies[ 16 ].tPos = Vec2< float >( 0.f, 1.f );
        vertecies[ 17 ].pos = Vec3<float >( right, top, front );
        vertecies[ 17 ].tPos = Vec2< float >( 1.f, 1.f );
        vertecies[ 18 ].pos = Vec3<float >( left, bottom, front );
        vertecies[ 18 ].tPos = Vec2< float >( 0.f, 0.f );
        vertecies[ 19 ].pos = Vec3<float >( right, bottom, front );
        vertecies[ 19 ].tPos = Vec2< float >( 1.f, 0.f );
        vertecies[ 20 ].pos = Vec3<float >( left, top, back );
        vertecies[ 20 ].tPos = Vec2< float >( 0.0f, 0.0f );
        vertecies[ 21 ].pos = Vec3<float >( right, top, back );
        vertecies[ 21 ].tPos = Vec2< float >( 1.0f, 0.0f );
        vertecies[ 22 ].pos = Vec3<float >( left, bottom, back );
        vertecies[ 22 ].tPos = Vec2< float >( 0.0f, 1.0f );
        vertecies[ 23 ].pos = Vec3<float >( right, bottom, back );
        vertecies[ 23 ].tPos = Vec2< float >( 1.0f, 1.0f );

        data->setVertecies( vertecies, 24 );
        // the order of the polygons has to be NORTH, EAST, SOUTH, WEST, TOP, BOTTOM according to the Area definition
        // down side
        Polygon3D* p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 6 + 16;
        p->indexList[ 1 ] = 2 + 16;
        p->indexList[ 2 ] = 3 + 16;
        p->indexList[ 3 ] = 6 + 16;
        p->indexList[ 4 ] = 3 + 16;
        p->indexList[ 5 ] = 7 + 16;
        data->addPolygon( p );
        // right side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 1 + 8;
        p->indexList[ 1 ] = 7 + 8;
        p->indexList[ 2 ] = 3 + 8;
        p->indexList[ 3 ] = 1 + 8;
        p->indexList[ 4 ] = 5 + 8;
        p->indexList[ 5 ] = 7 + 8;
        data->addPolygon( p );
        // top side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 4 + 16;
        p->indexList[ 1 ] = 1 + 16;
        p->indexList[ 2 ] = 0 + 16;
        p->indexList[ 3 ] = 4 + 16;
        p->indexList[ 4 ] = 5 + 16;
        p->indexList[ 5 ] = 1 + 16;
        data->addPolygon( p );
        // left side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 0 + 8;
        p->indexList[ 1 ] = 2 + 8;
        p->indexList[ 2 ] = 6 + 8;
        p->indexList[ 3 ] = 0 + 8;
        p->indexList[ 4 ] = 6 + 8;
        p->indexList[ 5 ] = 4 + 8;
        data->addPolygon( p );
        // back side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 4;
        p->indexList[ 1 ] = 6;
        p->indexList[ 2 ] = 7;
        p->indexList[ 3 ] = 4;
        p->indexList[ 4 ] = 7;
        p->indexList[ 5 ] = 5;
        data->addPolygon( p );
        // front side
        p = new Polygon3D();
        p->indexAnz = 6;
        p->indexList = new int[ p->indexAnz ];
        p->indexList[ 0 ] = 0;
        p->indexList[ 1 ] = 3;
        p->indexList[ 2 ] = 2;
        p->indexList[ 3 ] = 0;
        p->indexList[ 4 ] = 1;
        p->indexList[ 5 ] = 3;
        data->addPolygon( p );
        data->calculateNormals();
    }
    setModelDaten( data );
    Bild* b = new Bild();
    b->neuBild( 10, 10, 0xFFFFFFFF );
    Textur* tex = currentGame->zScreen()->zGraphicsApi()->createOrGetTextur( texture, 0 );
    if( !tex->zBild() )
        tex->setBildZ( b );
    else
        b->release();
    Model3DTextur* textur = new Model3DTextur();
    textur->setPolygonTextur( 0, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 1, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 2, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 3, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 4, dynamic_cast<Textur*>(tex->getThis()) );
    textur->setPolygonTextur( 5, tex );
    setModelTextur( textur );
    breakTextur = currentGame->zScreen()->zGraphicsApi()->createOrGetTextur( "blocks.ltdb/crack", 0 );
}

BasicBlock::~BasicBlock()
{
    breakTextur->release();
}

bool BasicBlock::needRenderPolygon( int index )
{
    return 1;
}

Textur* BasicBlock::zEffectTextur()
{
    if( hp < maxHP )
        return breakTextur;
    return 0;
}

float BasicBlock::getEffectPercentage()
{
    return 1 - hp / maxHP;
}


DirtBlockType::DirtBlockType()
    : BlockType( ID )
{}

void DirtBlockType::loadSuperBlock( Block* zBlock, Framework::StreamReader* zReader )
{
    BlockType::loadSuperBlock( zBlock, zReader );
}

Block* DirtBlockType::createBlock( Framework::Vec3<int> position )
{
    Block* b = new BasicBlock( DirtBlockType::INSTANCE, "blocks.ltdb/dirt", 0, position, 0 ); // TODO: add efective tool
    initializeSuperBlock( b );
    return b;
}

void DirtBlockType::initializeSuperBlock( Block* zBlock )
{
    BasicBlock* block = dynamic_cast<BasicBlock*>(zBlock);
    if( !block )
        throw "DirtBlockType::createSuperBlock was called with a block witch is not an instance of BasicBlock";
    block->transparent = 0;
    block->passable = 0;
    block->hp = 100;
    block->maxHP = 100;
    block->hardness = 1;
    block->zTool = 0;
    block->speedModifier = 1;
}

bool DirtBlockType::needsInstance() const
{
    return 1;
}


DirtBlockItemType::DirtBlockItemType()
    : BasicBlockItemType( ID )
{}

Item* DirtBlockItemType::createItem() const
{
    BasicBlockItem* item = new BasicBlockItem( (ItemType*)this, "Dirt" );
    return item;
}