FactoryCraft-Server/FactoryCraft/Game.h

#pragma once

#include <Critical.h>
#include <Network.h>
#include <Punkt.h>
#include <Text.h>
#include <Thread.h>

#include "Chat.h"
#include "Constants.h"
#include "Dimension.h"
#include "InMemoryBuffer.h"
#include "Player.h"
#include "PlayerRegister.h"
#include "Quest.h"
#include "RecipieLoader.h"
#include "Server.h"
#include "TickOrganizer.h"
#include "TypeRegistry.h"
#include "WorldGenerator.h"
#include "WorldLoader.h"
#include "WorldUpdate.h"
#include "UIController.h"

class FCKlient;

class GameClient : public Framework::Thread
{
private:
    Player* zPlayer;
    FCKlient* client;
    Critical background;
    Critical foreground;
    Critical other;
    Framework::Synchronizer updateSync;
    RCArray<InMemoryBuffer> requests;
    RCArray<WorldUpdate> updateQueue;
    RCArray<NetworkMessage> backgroundQueue;
    RCArray<NetworkMessage> foregroundQueue;
    Framework::Synchronizer foregroundQueueSync;
    Framework::Synchronizer backgroundQueueSync;
    Critical queueCs;
    Framework::Synchronizer emptyForegroundQueueSync;
    Framework::Synchronizer emptyBackgroundQueueSync;
    int viewDistance;
    bool first;
    bool online;
    bool finished;
    bool backgroundFinished;
    bool foregroundFinished;

public:
    GameClient(Player* zPlayer, FCKlient* client);
    ~GameClient();

    void thread() override;
    void sendWorldUpdate(WorldUpdate* update);
    void reply();
    void logout();
    void addMessage(StreamReader* reader);
    bool isOnline() const;
    void sendResponse(NetworkMessage* response);
    Player* zEntity() const;
    void sendTypes();

    class Message
    {
    public:
        inline static const unsigned char TERMINATE = 1;
        inline static const unsigned char WORLD_UPDATE = 2;
        inline static const unsigned char API_MESSAGE = 3;
        inline static const unsigned char POSITION_UPDATE = 4;
    };
};

class Game : public virtual Framework::Thread
{
private:
    Framework::Text name;
    TypeRegistry* typeRegistry;
    Framework::RCArray<Dimension>* dimensions;
    Framework::RCArray<WorldUpdate>* updates;
    Framework::RCArray<GameClient>* clients;
    Framework::Array<std::function<void()>> actions;
    QuestManager* questManager;
    Critical actionsCs;
    TickOrganizer* ticker;
    Framework::Text path;
    bool stop;
    __int64 tickId;
    Critical cs;
    int nextEntityId;
    WorldGenerator* generator;
    WorldLoader* loader;
    RecipieLoader recipies;
    Chat* chat;
    PlayerRegister* playerRegister;
    UIController* uiController;
    double totalTickTime;
    int tickCounter;
    double averageTickTime;
    int ticksPerSecond;
    double totalTime;

    void thread() override;

    Game(Framework::Text name, Framework::Text worldsDir);

public:
    ~Game();
    void initialize();
    void api(Framework::InMemoryBuffer* zRequest, GameClient* zOrigin);
    void updateLightning(int dimensionId, Vec3<int> location);
    void updateLightningWithoutWait(int dimensionId, Vec3<int> location);
    void broadcastMessage(NetworkMessage* response);
    void sendMessage(NetworkMessage* response, Entity* zTargetPlayer);
    bool requestWorldUpdate(WorldUpdate* update);
    bool checkPlayer(Framework::Text name, Framework::Text secret);
    bool existsPlayer(Framework::Text name);
    Framework::Text createPlayer(Framework::Text name);
    GameClient* addPlayer(FCKlient* client, Framework::Text name);
    bool doesChunkExist(int x, int y, int dimension);
    void blockTargetChanged(Block* zBlock);
    void entityTargetChanged(Entity* zEntity);
    void spawnItem(
        Framework::Vec3<float> location, int dimensionId, Item* stack);
    void spawnItem(
        Framework::Vec3<float> location, int dimensionId, ItemStack* stack);
    bool isChunkLoaded(int x, int y, int dimension) const;
    Framework::Either<Block*, int> zBlockAt(
        Framework::Vec3<int> location, int dimension) const;
    Block* zRealBlockInstance(Framework::Vec3<int> location, int dimension);
    int getBlockType(Framework::Vec3<int> location, int dimension);
    Dimension* zDimension(int id) const;
    static Framework::Punkt getChunkCenter(int x, int y);
    Area getChunckArea(Punkt center) const;
    Framework::Text getWorldDirectory() const;
    void requestArea(Area area);
    void save() const;
    void requestStop();
    void addDimension(Dimension* d);
    int getNextEntityId();
    WorldGenerator* zGenerator() const;
    Entity* zEntity(int id, int dimensionId) const;
    Entity* zEntity(int id) const;
    Entity* zNearestEntity(int dimensionId,
        Framework::Vec3<float> pos,
        std::function<bool(Entity*)> filter);
    const RecipieLoader& getRecipies() const;
    void doLater(std::function<void()> action);
    TickOrganizer* zTickOrganizer() const;
    Chat* zChat() const;
    Player* zPlayerByName(const char* name) const;
    TypeRegistry* zTypeRegistry() const;
    int getPlayerId(const char* name) const;
    QuestManager* zQuestManager() const;
    UIController* zUIController() const;

    double getAverageTickTime() const;
    int getTicksPerSecond() const;
    int getPlayerCount() const;
    int getChunkCount() const;

    static Game* INSTANCE;
    static Critical INSTANCE_CS;
    static void initialize(Framework::Text name, Framework::Text worldsDir);
};