FactoryCraft-Server/FactoryCraft/GameClient.cpp

#include "GameClient.h"

#include <AsynchronCall.h>

#include "Constants.h"
#include "Dimension.h"
#include "Game.h"
#include "ItemType.h"
#include "Player.h"
#include "Server.h"

GameClient::GameClient(Player* zPlayer, FCKlient* client)
    : Thread(),
      zPlayer(zPlayer),
      client(client),
      first(1),
      online(1),
      backgroundFinished(0),
      foregroundFinished(0)
{
    start();
}

GameClient::~GameClient()
{
    online = 0;
    emptyForegroundQueueSync.notifyAll();
    emptyBackgroundQueueSync.notifyAll();
    foregroundQueueSync.notify();
    backgroundQueueSync.notify();
    while (!foregroundFinished || !backgroundFinished)
        Sleep(100);
    client->release();
}

void GameClient::thread()
{
    new AsynchronCall("Game Client Background", [this]() {
        while (online)
        {
            queueCs.lock();
            if (backgroundQueue.has(0))
            {
                NetworkMessage* message = backgroundQueue.get(0);
                backgroundQueue.remove(0);
                queueCs.unlock();
                background.lock();
                message->writeTo(client->zBackgroundWriter());
                background.unlock();
                message->release();
            }
            else
            {
                queueCs.unlock();
                emptyBackgroundQueueSync.notifyAll();
                while (!backgroundQueueSync.wait(1000))
                {
                    emptyBackgroundQueueSync.notifyAll();
                }
            }
        }
        backgroundFinished = 1;
    });
    while (online)
    {
        queueCs.lock();
        if (foregroundQueue.has(0))
        {
            NetworkMessage* message = foregroundQueue.get(0);
            foregroundQueue.remove(0);
            queueCs.unlock();
            foreground.lock();
            message->writeTo(client->zForegroundWriter());
            foreground.unlock();
            message->release();
        }
        else
        {
            queueCs.unlock();
            emptyForegroundQueueSync.notifyAll();
            while (!foregroundQueueSync.wait(1000))
            {
                emptyForegroundQueueSync.notifyAll();
            }
        }
    }
    foregroundFinished = 1;
}

void GameClient::reply()
{
    other.lock();
    for (auto req : requests)
        Game::INSTANCE->api(req, this);
    requests.clear();
    other.unlock();
    if (first)
    {
        foreground.lock();
        int id = zPlayer->getId();
        client->zForegroundWriter()->write(
            (char*)&Message::POSITION_UPDATE, 1);
        client->zForegroundWriter()->write((char*)&id, 4);
        id = zPlayer->getDimensionId();
        client->zForegroundWriter()->write((char*)&id, 4);
        foreground.unlock();
        first = 0;
    }
}

void GameClient::logout()
{
    online = 0;
    emptyForegroundQueueSync.notifyAll();
    emptyBackgroundQueueSync.notifyAll();
    foregroundQueueSync.notify();
    backgroundQueueSync.notify();
}

void GameClient::addMessage(StreamReader* reader)
{
    short len = 0;
    reader->read((char*)&len, 2);
    InMemoryBuffer* buffer = new InMemoryBuffer();
    char* tmp = new char[len];
    reader->read(tmp, len);
    buffer->write(tmp, len);
    delete[] tmp;
    other.lock();
    requests.add(buffer);
    other.unlock();
}

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

void GameClient::sendResponse(NetworkMessage* response)
{
    queueCs.lock();
    if (response->isUseBackground())
    {
        if (backgroundQueue.getEntryCount() > 20)
        {
            queueCs.unlock();
            while (!emptyBackgroundQueueSync.wait(1000))
            {
                backgroundQueueSync.notify();
            }
            queueCs.lock();
        }
        backgroundQueue.add(response);
        queueCs.unlock();
        backgroundQueueSync.notify();
    }
    else
    {
        if (foregroundQueue.getEntryCount() > 100)
        {
            queueCs.unlock();
            Framework::Logging::warning()
                << "Game paused because nework connection to "
                << zPlayer->getName() << " is to slow.";
            Timer m;
            m.measureStart();
            while (foregroundQueue.getEntryCount() > 0)
            {
                foregroundQueueSync.notify();
                emptyForegroundQueueSync.wait(100);
            }
            m.measureEnd();
            Framework::Logging::warning()
                << "Game resumed after " << m.getSekunden() << " seconds.";
            queueCs.lock();
        }
        foregroundQueue.add(response);
        queueCs.unlock();
        foregroundQueueSync.notify();
    }
}

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

void GameClient::sendTypes()
{
    foreground.lock();
    int count = 0;
    for (int i = 0; i < Game::INSTANCE->getBlockTypeCount(); i++)
    {
        if (Game::INSTANCE->zBlockType(i)) count++;
    }
    client->zForegroundWriter()->write((char*)&count, 4);
    for (int i = 0; i < Game::INSTANCE->getBlockTypeCount(); i++)
    {
        const BlockType* t = Game::INSTANCE->zBlockType(i);
        if (t)
        {
            t->writeTypeInfo(client->zForegroundWriter());
        }
    }
    count = 0;
    for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
    {
        if (Game::INSTANCE->zItemType(i)) count++;
    }
    client->zForegroundWriter()->write((char*)&count, 4);
    for (int i = 0; i < Game::INSTANCE->getItemTypeCount(); i++)
    {
        const ItemType* t = Game::INSTANCE->zItemType(i);
        if (t)
        {
            int id = t->getId();
            client->zForegroundWriter()->write((char*)&id, 4);
            char len = (char)t->getName().getLength();
            client->zForegroundWriter()->write((char*)&len, 1);
            client->zForegroundWriter()->write(t->getName().getText(), len);
            Framework::XML::Element* tooltip = t->getTooltipUIML();
            Framework::Text tooltipText
                = tooltip ? tooltip->toString() : Framework::Text("");
            short tlen = (short)tooltipText.getLength();
            client->zForegroundWriter()->write((char*)&tlen, 2);
            client->zForegroundWriter()->write(tooltipText.getText(), tlen);
            tooltip->release();
            if (t->zModel())
            {
                t->zModel()->writeTo(client->zForegroundWriter());
            }
            else
            {
                ModelInfo("", Framework::RCArray<Framework::Text>(), false, 1.f)
                    .writeTo(client->zForegroundWriter());
            }
        }
    }
    count = 0;
    for (int i = 0; i < Game::INSTANCE->getEntityTypeCount(); i++)
    {
        if (Game::INSTANCE->zEntityType(i)) count++;
    }
    client->zForegroundWriter()->write((char*)&count, 4);
    for (int i = 0; i < count; i++)
    {
        const EntityType* t = Game::INSTANCE->zEntityType(i);
        int id = t->getId();
        client->zForegroundWriter()->write((char*)&id, 4);
        if (t->zModel())
        {
            t->zModel()->writeTo(client->zForegroundWriter());
        }
        else
        {
            ModelInfo("", Framework::RCArray<Framework::Text>(), false, 1.f)
                .writeTo(client->zForegroundWriter());
        }
    }
    foreground.unlock();
}