FactoryCraft-Server/FactoryCraft/Game.cpp

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

using namespace Framework;

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

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

void GameClient::sendWorldUpdate( WorldUpdate *zUpdate )
{
    if( zPlayer->getCurrentDimensionId() == zUpdate->getAffectedDimension() )
    {
        auto pos = ( Vec3<int> )zPlayer->getPosition();
        if( abs( pos.x - zUpdate->getMinAffectedPoint().x ) < viewDistance * CHUNK_SIZE || ( abs( pos.x - zUpdate->getMaxAffectedPoint().x ) < viewDistance * CHUNK_SIZE ) || abs( pos.y - zUpdate->getMinAffectedPoint().y ) < viewDistance * CHUNK_SIZE || ( abs( pos.y - zUpdate->getMaxAffectedPoint().y ) < viewDistance * CHUNK_SIZE ) )
        {
            cs.Enter();
            writer.schreibe( (char *)&Message::INGAME_MESSAGE, 1 );
            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++ )
        zGame->api( req, this );
    requests.leeren();
    cs.Leave();
    int x = (int)zPlayer->getPosition().x;
    int y = (int)zPlayer->getPosition().y;
    int d = zPlayer->getCurrentDimensionId();
    // send world to client
    if( first )
    {
        first = 0;
        for( int xP = x - CHUNK_SIZE * viewDistance; x <= x + CHUNK_SIZE * viewDistance; x += CHUNK_SIZE )
        {
            for( int yP = y - CHUNK_SIZE * viewDistance; y <= y + CHUNK_SIZE * viewDistance; y += CHUNK_SIZE )
            {
                Chunk *chunk = zGame->zDimension( d )->zChunk( zGame->getChunkCenter( xP, yP ) );
                if( chunk )
                {
                    AddChunkUpdate update( dynamic_cast<Chunk *>( chunk->getThis() ) );
                    sendWorldUpdate( &update );
                }
            }
        }
        zGame->requestArea( { x - CHUNK_SIZE * viewDistance, y - CHUNK_SIZE * viewDistance, x + CHUNK_SIZE * viewDistance, y + CHUNK_SIZE * viewDistance, d } );
    }
    else
    {
        Punkt lastMin = zGame->getChunkCenter( (int)lastPos.x - CHUNK_SIZE * viewDistance, (int)lastPos.y - CHUNK_SIZE * viewDistance );
        Punkt curMin = zGame->getChunkCenter( x - CHUNK_SIZE * viewDistance, y - CHUNK_SIZE * viewDistance );
        Punkt lastMax = zGame->getChunkCenter( (int)lastPos.x + CHUNK_SIZE * viewDistance, (int)lastPos.y + CHUNK_SIZE * viewDistance );
        Punkt curMax = zGame->getChunkCenter( x + CHUNK_SIZE * viewDistance, y + CHUNK_SIZE * viewDistance );
        for( int xP = curMin.x; x <= curMax.x; x += CHUNK_SIZE )
        {
            for( int yP = curMin.y; y <= curMax.y; y += CHUNK_SIZE )
            {
                if( xP < lastMin.x || xP > lastMax.x || yP < lastMin.y || yP > lastMax.y )
                {
                    Chunk *chunk = zGame->zDimension( d )->zChunk( zGame->getChunkCenter( x, y ) );
                    if( chunk )
                    {
                        AddChunkUpdate update( dynamic_cast<Chunk *>( chunk->getThis() ) );
                        sendWorldUpdate( &update );
                    }
                    else
                    {
                        zGame->requestArea( zGame->getChunckArea( Punkt( xP, yP ) ) );
                    }
                }
            }
        }
    }
    lastPos = zPlayer->getPosition();
}

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;
}

void GameClient::sendResponse( NetworkResponse *zResponse )
{
    if( zResponse->isAreaAffected( { lastPos.x - (float)CHUNK_SIZE * (float)viewDistance, lastPos.y - (float)CHUNK_SIZE * (float)viewDistance, 0.f }, { lastPos.x + (float)CHUNK_SIZE * (float)viewDistance, lastPos.y + (float)CHUNK_SIZE * (float)viewDistance, (float)WORLD_HEIGHT } ) )
    {
        cs.Leave();
        writer.schreibe( (char *)&Message::INGAME_MESSAGE, 1 );
        writer.schreibe( (char *)&Message::API_MESSAGE, 1 );
        zResponse->writeTo( client->zWriter() );
        cs.Leave();
    }
}

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>() ),
    ticker( new TickOrganizer() ),
    path( (const char *)( worldsDir + "/" + name ) ),
    stop( 0 ),
    tickId( 0 ),
    nextEntityId( 0 ),
    generator( 0 ),
    loader( 0 )
{
    if( !DateiExistiert( worldsDir + "/" + name ) )
        DateiPfadErstellen( worldsDir + "/" + name + "/" );
    Datei d;
    d.setDatei( path + "/eid" );
    if( d.existiert() )
    {
        d.open( Datei::Style::lesen );
        d.lese( (char *)&nextEntityId, 4 );
        d.close();
    }
    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 );
    loader = new WorldLoader( 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::api( Framework::StreamReader *zRequest, GameClient *zOrigin )
{
    char type;
    zRequest->lese( &type, 1 );
    NetworkResponse response;
    switch( type )
    {
    case 1: // world
    {
        int dimensionId;
        zRequest->lese( (char *)&dimensionId, 4 );
        Dimension *dim = zDimension( dimensionId );
        if( !dim )
        {
            dim = new Dimension( dimensionId );
            addDimension( dim );
        }
        dim->api( zRequest, &response );
        break;
    }
    default:
        std::cout << "received unknown api request in game with type " << (int)type << "\n";
    }
    if( response.isBroadcast() )
        distributeResponse( &response );
    else
        zOrigin->sendResponse( &response );
}

void Game::distributeResponse( NetworkResponse *zResponse )
{
    for( auto client = clients->getIterator(); client; client++ )
        client->sendResponse( zResponse );
}

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 ) );
}

Area Game::getChunckArea( Punkt center ) const
{
    return { center.x - CHUNK_SIZE / 2, center.y - CHUNK_SIZE / 2, center.x + CHUNK_SIZE / 2, center.y + CHUNK_SIZE / 2, 0 };
}

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

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

void Game::save() const
{
    Datei d;
    d.setDatei( path + "/eid" );
    d.open( Datei::Style::schreiben );
    d.schreibe( (char *)&nextEntityId, 4 );
    d.close();
    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 );
}

int Game::getNextEntityId()
{
    cs.Enter();
    int result = nextEntityId++;
    cs.Leave();
    return result;
}