FactoryCraft-Client/FactoryCraft/World.cpp

#include <Network.h>
#include <Welt3D.h>
#include "World.h"
#include "Globals.h"
#include "WorldUpdate.h"
#include "Constants.h"

using namespace Network;
using namespace Framework;

World::World( Bildschirm3D *zScreen )
    : Thread()
{
    renderedWorld = new Welt3D();
    dimensions = new RCArray<Dimension>();
    currentPlayer = new CurrentPlayer();
    zScreenPtr = zScreen;
    kam = new Kam3D();
    kam->setWelt( renderedWorld );
    zScreen->addKamera( kam );
    start();
}

World::~World()
{
    zScreenPtr->removeKamera( kam );
    dimensions->release();
    currentPlayer->release();
}

void World::update()
{
    NetworkReader *serverMessageReader = 0;
    const char type = 0;
    while( serverMessageReader = network->zFactoryClient()->getNextMessage() )
    {
        serverMessageReader->lese( (char *)&type, 1 );
        if( type == 2 ) // WORLD UPDATE
        {
            int id = 0;
            serverMessageReader->lese( (char *)&id, 4 );
            StaticRegistry<WorldUpdateType>::INSTANCE.zElement( id )->applyUpdate( serverMessageReader );
        }
        if( type == 3 ) // API MESSAGE
        {
            // TODO: process messages
        }
        if( type == 4 ) // POSITION UPDATE
        {
            Vec3<float> pos, dir;
            serverMessageReader->lese( (char *)&pos.x, 4 );
            serverMessageReader->lese( (char *)&pos.y, 4 );
            serverMessageReader->lese( (char *)&pos.z, 4 );
            kam->setPosition( pos );
            serverMessageReader->lese( (char *)&dir.x, 4 );
            serverMessageReader->lese( (char *)&dir.y, 4 );
            dir.z = 0;
            if( dir.getLengthSq() > 0 )
                kam->setAusrichtung( pos + dir * 10 );
        }
    }
}

void World::setChunk( Chunk *chunk, int dimensionId )
{
    Dimension *zDim = zDimension( dimensionId );
    if( !zDim )
    {
        zDim = new Dimension( dimensionId );
        dimensions->add( zDim );
    }
    zDim->addChunk( chunk );
    zDim->updateVisibility();
}

void World::thread()
{
    while( true )
    {
        zScreenPtr->lock();
        if( currentGame != this )
        {
            zScreenPtr->unlock();
            return;
        }
        update();
        zScreenPtr->unlock();
        Sleep( 10 );
    }
}

Block *World::zBlockAt( Framework::Vec3<int> location, int dimension ) const
{
    Dimension *dim = zDimension( dimension );
    if( dim )
        return dim->zBlock( location );
    return 0;
}

Dimension *World::zDimension( int id ) const
{
    for( auto dim = dimensions->getIterator(); dim; dim++ )
    {
        if( dim->getDimensionId() == id )
            return dim;
    }
    return 0;
}

void World::setVisibility( Framework::Model3D *zModel, bool visible )
{
    if( visible )
        renderedWorld->addZeichnung( dynamic_cast<Framework::Model3D *>(zModel->getThis()) );
    else
        renderedWorld->removeZeichnung( zModel );
}

Framework::Bildschirm3D *World::zScreen() const
{
    return zScreenPtr;
}

Framework::Punkt World::getChunkCenter( int x, int y ) const
{
    return Punkt( (x / CHUNK_SIZE) * CHUNK_SIZE + (x < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2, (y / CHUNK_SIZE) * CHUNK_SIZE + (y < 0 ? -CHUNK_SIZE : CHUNK_SIZE) / 2 );
}