Root.h

Go to the documentation of this file.

#pragma once

#include "Protocol/Authenticator.h"
#include "Protocol/MojangAPI.h"
#include "HTTP/HTTPServer.h"
#include "Defines.h"
#include "FunctionRef.h"
#include "RankManager.h"
#include "BlockTypeRegistry.h"





// fwd:
class cMonsterConfig;
class cBrewingRecipes;
class cCraftingRecipes;
class cFurnaceRecipe;
class cWebAdmin;
class cPluginManager;
class cServer;
class cWorld;
class cPlayer;
class cCommandOutputCallback;
class cCompositeChat;
class cSettingsRepositoryInterface;
class cDeadlockDetect;
class cUUID;
class BlockTypePalette;
class ProtocolPalettes;

using cPlayerListCallback =  cFunctionRef<bool(cPlayer &)>;
using cWorldListCallback  =  cFunctionRef<bool(cWorld  &)>;

namespace Json
{
    class Value;
}





// tolua_begin
class cRoot
{
public:
    static cRoot * Get() { return s_Root; }
    // tolua_end

    static bool m_TerminateEventRaised;
    static bool m_RunAsService;

    AString m_SettingsFilename;

    cRoot(void);
    ~cRoot();

    void Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo);

    void StopServer();

    // tolua_begin
    cServer * GetServer(void) { return m_Server; }
    cWorld *  GetDefaultWorld(void);

    cWorld * GetWorld(const AString & a_WorldName);

    int GetServerUpTime(void)
    {
        return static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - m_StartTime).count());
    }
    // tolua_end

    bool ForEachWorld(cWorldListCallback a_Callback);  // >> Exported in ManualBindings <<

    void LogChunkStats(cCommandOutputCallback & a_Output);

    cMonsterConfig * GetMonsterConfig(void) { return m_MonsterConfig; }

    cCraftingRecipes * GetCraftingRecipes(void) { return m_CraftingRecipes; }  // tolua_export
    cFurnaceRecipe *   GetFurnaceRecipe  (void) { return m_FurnaceRecipe; }    // Exported in ManualBindings.cpp with quite a different signature
    cBrewingRecipes *  GetBrewingRecipes (void) { return m_BrewingRecipes.get(); }    // Exported in ManualBindings.cpp

    BlockTypeRegistry & GetBlockTypeRegistry() { return m_BlockTypeRegistry; }

    const BlockTypePalette & GetUpgradeBlockTypePalette() const { return *m_UpgradeBlockTypePalette; }

    ProtocolPalettes & GetProtocolPalettes() const { return *m_ProtocolPalettes; }

    static int GetFurnaceFuelBurnTime(const cItem & a_Fuel);  // tolua_export

    AStringVector GetPlayerTabCompletionMultiWorld(const AString & a_Text);

    std::chrono::steady_clock::time_point m_StartTime;

    cWebAdmin *        GetWebAdmin       (void) { return m_WebAdmin; }         // tolua_export
    cPluginManager *   GetPluginManager  (void) { return m_PluginManager; }    // tolua_export
    cAuthenticator &   GetAuthenticator  (void) { return m_Authenticator; }
    cMojangAPI &       GetMojangAPI      (void) { return *m_MojangAPI; }
    cRankManager *     GetRankManager    (void) { return m_RankManager.get(); }

    void QueueExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);

    void QueueExecuteConsoleCommand(const AString & a_Cmd);  // tolua_export

    void ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);

    void KickUser(int a_ClientID, const AString & a_Reason);

    void AuthenticateUser(int a_ClientID, const AString & a_Name, const cUUID & a_UUID, const Json::Value & a_Properties);

    void TickCommands(void);

    int GetTotalChunkCount(void);  // tolua_export

    void SaveAllChunks(void);  // tolua_export

    void SetSavingEnabled(bool a_SavingEnabled);  // tolua_export

    bool ForEachPlayer(cPlayerListCallback a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<

    bool FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallback a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<

    bool DoWithPlayerByUUID(const cUUID & a_PlayerUUID, cPlayerListCallback a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<

    bool DoWithPlayer(const AString & a_PlayerName, cPlayerListCallback a_Callback);

    void SendPlayerLists(cPlayer * a_DestPlayer);

    void BroadcastPlayerListsAddPlayer(const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);

    void BroadcastPlayerListsRemovePlayer(const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);

    // tolua_begin

    void BroadcastChat       (const AString & a_Message, eMessageType a_ChatPrefix = mtCustom);
    void BroadcastChat       (const cCompositeChat & a_Message);
    void BroadcastChatDeath  (const AString & a_Message) { BroadcastChat(a_Message, mtDeath); }
    void BroadcastChatFailure(const AString & a_Message) { BroadcastChat(a_Message, mtFailure); }
    void BroadcastChatFatal  (const AString & a_Message) { BroadcastChat(a_Message, mtFailure); }
    void BroadcastChatInfo   (const AString & a_Message) { BroadcastChat(a_Message, mtInformation); }
    void BroadcastChatJoin   (const AString & a_Message) { BroadcastChat(a_Message, mtJoin); }
    void BroadcastChatLeave  (const AString & a_Message) { BroadcastChat(a_Message, mtLeave); }
    void BroadcastChatSuccess(const AString & a_Message) { BroadcastChat(a_Message, mtSuccess); }
    void BroadcastChatWarning(const AString & a_Message) { BroadcastChat(a_Message, mtWarning); }

    static AString GetProtocolVersionTextFromInt(int a_ProtocolVersionNum);

    static int GetVirtualRAMUsage(void);

    static int GetPhysicalRAMUsage(void);

    // tolua_end

private:
    class cCommand
    {
    public:
        cCommand(const AString & a_Command, cCommandOutputCallback * a_Output) :
            m_Command(a_Command),
            m_Output(a_Output)
        {
        }

        AString m_Command;
        cCommandOutputCallback * m_Output;
    } ;

    typedef std::map<AString, cWorld *> WorldMap;
    typedef std::vector<cCommand> cCommandQueue;

    cWorld * m_pDefaultWorld;
    WorldMap m_WorldsByName;

    cCriticalSection m_CSPendingCommands;
    cCommandQueue    m_PendingCommands;

    std::thread m_InputThread;
    cEvent m_StopEvent;
    std::atomic_flag m_InputThreadRunFlag;

    cServer *        m_Server;
    cMonsterConfig * m_MonsterConfig;

    cCraftingRecipes * m_CraftingRecipes;
    cFurnaceRecipe *   m_FurnaceRecipe;
    std::unique_ptr<cBrewingRecipes> m_BrewingRecipes;
    cWebAdmin *        m_WebAdmin;
    cPluginManager *   m_PluginManager;
    cAuthenticator     m_Authenticator;
    cMojangAPI *       m_MojangAPI;

    std::unique_ptr<cRankManager> m_RankManager;

    cHTTPServer m_HTTPServer;

    BlockTypeRegistry m_BlockTypeRegistry;

    std::unique_ptr<BlockTypePalette> m_UpgradeBlockTypePalette;

    std::unique_ptr<ProtocolPalettes> m_ProtocolPalettes;


    void LoadGlobalSettings();

    void LoadPalettes(const AString & aProtocolFolder);

    void LoadWorlds(cDeadlockDetect & a_dd, cSettingsRepositoryInterface & a_Settings, bool a_IsNewIniFile);

    void StartWorlds(cDeadlockDetect & a_DeadlockDetect);

    void StopWorlds(cDeadlockDetect & a_DeadlockDetect);

    void UnloadWorlds(void);

    void DoExecuteConsoleCommand(const AString & a_Cmd);

    static cRoot * s_Root;

    static void InputThread(cRoot & a_Params);
};  // tolua_export