FactoryCraft-Server/FactoryCraft/Game.cpp

#include "Game.h"
#include "Zeit.h"
#include "Player.h"
#include "OverworldDimension.h"

using namespace Framework;

GameClient::GameClient( Player *zPlayer, FCKlient *client )
    : ReferenceCounter(),
    zPlayer( zPlayer ),
    client( client ),
    writer( client->zClient() ),
    online( 1 )
{}

GameClient::~GameClient()
{
    client->release();
}

void GameClient::sendWorldUpdate( WorldUpdate *zUpdate )
{
    cs.Enter();
    writer.schreibe( (char *)&Message::WORLD_UPDATE, 1 );
    zUpdate->write( &writer );
    cs.Leave();
}

void GameClient::reply( Game *zGame )
{
    cs.Enter();
    for( auto req = requests.getIterator(); req; req++ )
    {
        // TODO
    }
    requests.leeren();
    cs.Leave();
}

void GameClient::logout()
{
    online = 0;
}

void GameClient::addMessage( StreamReader *reader )
{
    short len = 0;
    reader->lese( (char *)&len, 2 );
    InMemoryBuffer *buffer = new InMemoryBuffer();
    char *tmp = new char[ len ];
    reader->lese( tmp, len );
    buffer->schreibe( tmp, len );
    delete[]tmp;
    cs.Enter();
    requests.add( buffer );
    cs.Leave();
}

bool GameClient::isOnline() const
{
    return online;
}

Player *GameClient::zEntity() const
{
    return zPlayer;
}


Game::Game( Framework::Text name, Framework::Text worldsDir )
    : Thread(),
    name( name ),
    dimensions( new RCArray<Dimension>() ),
    updates( new RCArray<WorldUpdate>() ),
    clients( new RCArray<GameClient>() ),
    generator( 0 ),
    loader( new WorldLoader( this ) ),
    ticker( new TickOrganizer() ),
    path( (const char *)( worldsDir + "/" + name ) ),
    stop( 0 ),
    tickId( 0 )
{
    if( !DateiExistiert( worldsDir + "/" + name ) )
        DateiPfadErstellen( worldsDir + "/" + name + "/" );
    int seed = 0;
    int index = 0;
    for( char *n = name; n; n++ )
        seed += (int)pow( (float)*n * 31, ( float )++index );
    generator = new WorldGenerator( seed, this );
    start();
}

Game::~Game()
{
    dimensions->release();
    updates->release();
    clients->release();
    generator->release();
    loader->release();
}

void Game::thread()
{
    ZeitMesser m;
    while( !stop )
    {
        m.messungStart();
        ticker->nextTick();
        int index = 0;
        Array<int> removed;
        cs.Enter();
        for( auto player = clients->getIterator(); player; player++, index++ )
        {
            if( !player->isOnline() )
            {
                Datei pFile;
                pFile.setDatei( path + "/player/" + player->zEntity()->getName() );
                if( pFile.open( Datei::Style::schreiben ) )
                    PlayerEntityType::INSTANCE->saveEntity( player->zEntity(), &pFile );
                removed.add( player, 0 );
            }
        }
        for( auto i = removed.getIterator(); i; i++ )
            clients->remove( i );
        cs.Leave();
        for( auto dim = dimensions->getIterator(); dim; dim++ )
            dim->tickEntities( this );
        while( updates->z( 0 ) )
        {
            WorldUpdate *update = updates->z( 0 );
            for( auto client = clients->getIterator(); client; client++ )
                client->sendWorldUpdate( update );
            if( !zDimension( update->getAffectedDimension() ) )
                addDimension( new Dimension( update->getAffectedDimension() ) );
            update->onUpdate( zDimension( update->getAffectedDimension() ) );
            updates->remove( 0 );
        }
        for( auto client = clients->getIterator(); client; client++ )
            client->reply( this );
        m.messungEnde();
        double sec = m.getSekunden();
        if( sec < 0.05 )
            Sleep( (int)( ( 0.05 - sec ) * 1000 ) );
    }
    save();
}

void Game::requestWorldUpdate( WorldUpdate *update )
{
    cs.Enter();
    updates->add( update );
    cs.Leave();
}

GameClient *Game::addPlayer( FCKlient *client, Framework::Text name )
{
    cs.Enter();
    Datei pFile;
    pFile.setDatei( path + "/player/" + name );
    Player *player;
    if( !pFile.existiert() || !pFile.open( Datei::Style::lesen ) )
    {
        player = (Player *)PlayerEntityType::INSTANCE->createEntityAt( Vec3<float>( 0, 0, 0 ), OverworldDimension::ID, this );
    }
    else
    {
        player = (Player *)PlayerEntityType::INSTANCE->loadEntity( this, &pFile );
        pFile.close();
    }
    requestArea( { (int)player->getPosition().x - 100, (int)player->getPosition().y - 100, (int)player->getPosition().x + 100, (int)player->getPosition().y + 100, player->getCurrentDimensionId() } );
    while( !zDimension( OverworldDimension::ID ) )
    {
        cs.Leave();
        Sleep( 1000 );
        cs.Enter();
    }
    zDimension( OverworldDimension::ID )->addEntity( player );
    GameClient *gameClient = new GameClient( player, client );
    clients->add( gameClient );
    cs.Leave();
    return dynamic_cast<GameClient *>( gameClient->getThis() );
}

bool Game::doesChunkExist( int x, int y, int dimension ) const
{
    Dimension *dim = zDimension( dimension );
    return ( dim && dim->hasChunck( x, y ) ) || loader->existsChunk( x, y, dimension );
}

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

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

Framework::Punkt Game::getChunkCenter( int x, int y ) const
{
    return Punkt( (int)floor( ( (float)x + CHUNK_SIZE / 2 ) / CHUNK_SIZE ), (int)floor( ( (float)y + CHUNK_SIZE / 2 ) / CHUNK_SIZE ) );
}

Framework::Text Game::getWorldDirectory() const
{
    return path;
}

void Game::requestArea( Area area )
{
    generator->requestGeneration( area );
    loader->requestLoading( area );
}

void Game::save() const
{
    for( auto dim = dimensions->getIterator(); dim; dim++ )
        dim->save( path );
}

void Game::requestStop()
{
    stop = 1;
    warteAufThread( 1000000 );
}

void Game::addDimension( Dimension *d )
{
    dimensions->add( d );
}