Root.h

Go to the documentation of this file.

 
#pragma once
 
#include "Defines.h"
#include "FunctionRef.h"
#include "HTTP/HTTPServer.h"
#include "Protocol/Authenticator.h"
#include "Protocol/MojangAPI.h"
#include "RankManager.h"
#include "ChunkDef.h"
 
 
 
 
// fwd:
class cItem;
class cMonsterConfig;
class cBrewingRecipes;
class cCraftingRecipes;
class cRecipeMapper;
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
 
    AString m_SettingsFilename;
 
    cRoot(void);
    ~cRoot();
 
    bool Run(cSettingsRepositoryInterface & a_OverridesRepo);
 
    static void Stop();
 
    static void Restart();
 
    // 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
    cRecipeMapper * GetRecipeMapper(void) { return m_RecipeMapper.get(); }
    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; }
 
    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 KickUser(int a_ClientID, const AString & a_Reason);
 
    size_t GetTotalChunkCount(void);  // tolua_export
 
    void SaveAllChunks(void);  // tolua_export
 
    void SaveAllChunksNow(void);
 
    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);
 
    void BroadcastPlayerListsHeaderFooter(const cCompositeChat & a_Header, const cCompositeChat & a_Footer);  // tolua_export
 
    // 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:
 
    enum class NextState
    {
        Run,
        Restart,
        Stop
    };
 
    typedef std::map<AString, cWorld> WorldMap;
 
    void HandleInput();
 
    static void TransitionNextState(NextState a_NextState);
 
    cWorld * m_pDefaultWorld;
    WorldMap m_WorldsByName;
 
    static cEvent s_StopEvent;
 
    cServer *        m_Server;
    cMonsterConfig * m_MonsterConfig;
 
    cCraftingRecipes * m_CraftingRecipes;
    std::unique_ptr<cRecipeMapper> m_RecipeMapper;
    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;
 
 
    void LoadGlobalSettings();
 
    void LoadWorlds(cDeadlockDetect & a_dd, cSettingsRepositoryInterface & a_Settings, bool a_IsNewIniFile);
 
    void StartWorlds(cDeadlockDetect & a_DeadlockDetect);
 
    void StopWorlds(cDeadlockDetect & a_DeadlockDetect);
 
    static cRoot * s_Root;
 
    static std::atomic<NextState> s_NextState;
};  // tolua_export