ServerInstance.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
#include "mc/events/WorldSaveAndExitPackTelemetryData.h"
 
// auto generated inclusion list
#include "mc/deps/application/AppPlatformListener.h"
#include "mc/deps/application/LowMemorySeverity.h"
#include "mc/deps/core/file/LevelStorageState.h"
#include "mc/deps/core/file/StorageAreaStateListener.h"
#include "mc/deps/core/threading/Async.h"
#include "mc/deps/core/utility/EnableNonOwnerReferences.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/core/utility/ServiceRegistrationToken.h"
#include "mc/deps/core/utility/UniqueOwnerPointer.h"
#include "mc/deps/ecs/gamerefs_entity/EntityContext.h"
#include "mc/deps/game_refs/OwnerPtr.h"
#include "mc/network/ConnectionDefinition.h"
#include "mc/network/connection/DisconnectFailReason.h"
#include "mc/platform/brstd/move_only_function.h"
#include "mc/server/ServerGraphicsSettings.h"
#include "mc/server/ServerInstanceInitArguments.h"
#include "mc/server/commands/CommandsRegistryConfiguration.h"
#include "mc/world/GameCallbacks.h"
#include "mc/world/level/LevelSettings.h"
#include "mc/world/level/storage/Experiments.h"
 
// auto generated forward declare list
// clang-format off
class AppPlatform;
class CDNConfig;
class ChatLoggingEventListener;
class DebuggerDiagnostics;
class EducationOptions;
class ILevel;
class IMinecraftEventing;
class IResourcePackRepository;
class ItemRegistry;
class KeyManager;
class LevelData;
class LevelStorage;
class LinkedAssetValidator;
class LocalProfilerControlBroker;
class LoopbackPacketSender;
class Minecraft;
class ResourcePackManager;
class Scheduler;
class ScriptPackSettingsCache;
class ServerInstanceEventCoordinator;
class ServerLevel;
class ServerNetworkSystem;
class ServerScriptManager;
class ServerTextSettings;
class TextFilteringProcessor;
class Timer;
class WorldSessionEndPoint;
struct BiomeJsonDocumentGlueResolvedBiomeData;
struct DimensionFactoryAndManager;
struct NetworkServerConfig;
struct ServerInstanceArguments;
struct ServerInstanceInitArguments;
struct ServerNetworkHandlerDependencies;
struct ServerPerformanceData;
struct WorldSaveAndExitPackTelemetryData;
namespace Core { class FileStorageArea; }
namespace Editor { class IEditorManager; }
namespace Scripting { class RegistryManager; }
namespace ServerInitialization { class IServerInitializer; }
namespace ServerInitialization { struct ServerInitResult; }
namespace ServerInstanceMessenger { class IMessenger; }
namespace br::worldgen { class StructureSetRegistry; }
namespace cereal { struct ReflectionCtx; }
// clang-format on
 
class ServerInstance : public ::Bedrock::EnableNonOwnerReferences,
                       public ::AppPlatformListener,
                       public ::GameCallbacks,
                       public ::Core::StorageAreaStateListener {
public:
    // ServerInstance inner types declare
    // clang-format off
    struct CreateServerLevelOps;
    struct NetworkToggleOptions;
    struct PostLevelArgs;
    struct LevelInitArgs;
    // clang-format on
 
    // ServerInstance inner types define
    enum class InstanceState : int {
        Running          = 0,
        Suspended        = 1,
        WaitingLeaveGame = 2,
        Stopped          = 3,
        NotStarted       = 4,
    };
 
    struct CreateServerLevelOps {
    public:
        // CreateServerLevelOps inner types define
        using CreateDimensionFactoryCallback =
            ::brstd::move_only_function<::std::unique_ptr<::DimensionFactoryAndManager>(
                ::Bedrock::NotNullNonOwnerPtr<::ILevel>,
                ::br::worldgen::StructureSetRegistry&
            ) const>;
 
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, ::ServerInstance&>      mInstance;
        ::ll::TypedStorage<1, 1, bool>                   mServerAuthSound;
        ::ll::TypedStorage<8, 8, ::IMinecraftEventing&>  mEventing;
        ::ll::TypedStorage<8, 8, ::ResourcePackManager&> mClientResourcePackManager;
        ::ll::TypedStorage<
            8,
            64,
            ::brstd::move_only_function<::std::unique_ptr<::DimensionFactoryAndManager>(
                ::Bedrock::NotNullNonOwnerPtr<::ILevel>,
                ::br::worldgen::StructureSetRegistry&
            ) const>>
            mCreateDimensionFactoryAndManager;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        CreateServerLevelOps& operator=(CreateServerLevelOps const&);
        CreateServerLevelOps(CreateServerLevelOps const&);
        CreateServerLevelOps();
    };
 
    struct NetworkToggleOptions {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, ::AppPlatform const&>          mPlatform;
        ::ll::TypedStorage<1, 1, bool>                          mDisableLanSignaling;
        ::ll::TypedStorage<1, 1, bool>                          mIsServerVisibleToLanDiscovery;
        ::ll::TypedStorage<1, 1, bool>                          mEnablePacketRateLimiting;
        ::ll::TypedStorage<8, 8, ::ConnectionDefinition const&> mConnectionDefinition;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        NetworkToggleOptions& operator=(NetworkToggleOptions const&);
        NetworkToggleOptions(NetworkToggleOptions const&);
        NetworkToggleOptions();
    };
 
    struct PostLevelArgs {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ServerLevel>>                          mLevel;
        ::ll::TypedStorage<8, 72, ::Experiments>                                            mExperiments;
        ::ll::TypedStorage<8, 1344, ::LevelSettings>                                        mLevelSettings;
        ::ll::TypedStorage<8, 8, ::ResourcePackManager&>                                    mClientResourcePackManager;
        ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::IResourcePackRepository>> mResourcePackRepository;
        ::ll::TypedStorage<8, 104, ::std::optional<::CommandsRegistryConfiguration const>>
                                                                                mCommandsRegistryConfiguration;
        ::ll::TypedStorage<4, 20, ::ConnectionDefinition>                       mConnectionDefinition;
        ::ll::TypedStorage<8, 32, ::OwnerPtr<::EntityContext>>                  mLevelEntityContext;
        ::ll::TypedStorage<8, 16, ::std::shared_ptr<::ScriptPackSettingsCache>> mPackSettingsCache;
        ::ll::TypedStorage<1, 1, bool>                                          mEnableItemStackNetManager;
        ::ll::TypedStorage<
            8,
            64,
            ::brstd::move_only_function<bool(::ServerInstanceInitArguments::HostMultiplayerArguments&&) const>>
            mHostMultiplayer;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        PostLevelArgs& operator=(PostLevelArgs const&);
        PostLevelArgs(PostLevelArgs const&);
        PostLevelArgs();
    };
 
    struct LevelInitArgs {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 32, ::std::string> mLevelName;
        ::ll::TypedStorage<
            8,
            64,
            ::std::unordered_map<::std::string, ::std::unique_ptr<::BiomeJsonDocumentGlueResolvedBiomeData>>>
                                                                                      mBiomeIdToResolvedData;
        ::ll::TypedStorage<8, 16, ::std::shared_ptr<::ServerInstance::PostLevelArgs>> mPost;
        // NOLINTEND
    };
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 8, ::std::chrono::steady_clock::time_point>                          mLastSyncTime;
    ::ll::TypedStorage<1, 1, bool const>                                                       mIsDedicatedServer;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Minecraft>>                                   mMinecraft;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::ServerNetworkSystem>>                        mNetwork;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::LoopbackPacketSender>>                        mPacketSender;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Timer>>                                       mSimTimer;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Timer>>                                       mRealTimer;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Scheduler>>                                   mScheduler;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::EducationOptions>>                            mEducationOptions;
    ::ll::TypedStorage<8, 8, ::LevelStorage*>                                                  mStorage;
    ::ll::TypedStorage<1, 1, ::std::atomic<bool>>                                              mInUpdate;
    ::ll::TypedStorage<4, 4, ::std::atomic<int>>                                               mWriteRefCounter;
    ::ll::TypedStorage<1, 1, ::std::atomic<bool>>                                              mThreadShouldJoin;
    ::ll::TypedStorage<8, 80, ::std::mutex>                                                    mMutexDestruction;
    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::ServerInstanceEventCoordinator>> mEventCoordinator;
    ::ll::TypedStorage<4, 4, ::std::atomic<::ServerInstance::InstanceState>>                   mInstanceState;
    ::ll::TypedStorage<8, 16, ::std::thread>                                                   mServerInstanceThread;
    ::ll::TypedStorage<8, 80, ::std::mutex>                                                    mResumeMutex;
    ::ll::TypedStorage<8, 72, ::std::condition_variable>                                       mResumeSignal;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Scripting::RegistryManager>>                  mScriptRegistryManager;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ServerScriptManager>>                         mServerScriptManager;
    ::ll::TypedStorage<8, 64, ::std::function<void(char const*)>> mScriptWatchdogCriticalErrorCallback;
    ::ll::TypedStorage<8, 64, ::std::function<void(::Connection::DisconnectFailReason, char const*)>>
                                                                           mUnrecoverableErrorCallback;
    ::ll::TypedStorage<1, 1, bool>                                         mHandledLevelCorruption;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::TextFilteringProcessor>>  mTextFilteringProcessor;
    ::ll::TypedStorage<8, 8, ::std::chrono::microseconds>                  mWakeupInterval;
    ::ll::TypedStorage<8, 32, ::std::string>                               mLevelId;
    ::ll::TypedStorage<8, 32, ::std::string>                               mServerName;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::WorldSessionEndPoint>>    mWorldSessionEndPoint;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::Core::FileStorageArea>>  mStorageAreaForLevel;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::ItemRegistry>>           mServerItemRegistry;
    ::ll::TypedStorage<1, 1, bool>                                         mEnableItemStackNetManager;
    ::ll::TypedStorage<1, 1, bool>                                         mEnableRealmsStories;
    ::ll::TypedStorage<1, 1, bool>                                         mbFlaggedForEarlyDestruction;
    ::ll::TypedStorage<8, 8, ::ServiceRegistrationToken<::ServerInstance>> mServiceRegistrationToken;
    ::ll::TypedStorage<1, 1, bool>                                         mHasScheduledLeaveGame;
    ::ll::TypedStorage<8, 32, ::std::optional<::std::vector<::WorldSaveAndExitPackTelemetryData>>>
                                                                                      mWorldSaveAndExitPackTelemetry;
    ::ll::TypedStorage<1, 1, bool>                                                    mCriticalDiskErrorTelemetrySent;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Editor::IEditorManager>>             mEditorManager;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::CDNConfig>>                mCDNConfig;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::ServerTextSettings>>       mServerTextSettings;
    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::cereal::ReflectionCtx>> mCerealContext;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::LinkedAssetValidator>>               mLinkedAssetValidator;
    ::ll::TypedStorage<1, 1, ::ServerGraphicsSettings>                                mGraphicsSettings;
    ::ll::TypedStorage<8, 8, ::gsl::not_null<::std::unique_ptr<::ServerInstanceMessenger::IMessenger>>> mMessenger;
    ::ll::TypedStorage<8, 64, ::brstd::move_only_function<bool() const>>    mShouldDisableNetworkOnSuspend;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ChatLoggingEventListener>> mChatLoggingEventListener;
    ::ll::TypedStorage<8, 16, ::Bedrock::UniqueOwnerPointer<::LocalProfilerControlBroker>>  mLocalProfilerControlBroker;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ServerInitialization::IServerInitializer>> mInitializer;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::DebuggerDiagnostics>>                      mDebuggerDiagnostics;
    ::ll::TypedStorage<8, 8, ::ServiceRegistrationToken<::DebuggerDiagnostics>>             mDebuggerDiagnosticsToken;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ServerPerformanceData>>                    mServerPerformanceData;
    ::ll::TypedStorage<8, 8, ::ServiceRegistrationToken<::ServerPerformanceData>>
        mServerPerformanceDataRegistrationToken;
    // NOLINTEND
 
public:
    // prevent constructor by default
    ServerInstance();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~ServerInstance() /*override*/ = default;
 
    virtual void onLowMemory(::LowMemorySeverity) /*override*/;
 
    virtual void onLevelCorrupt() /*override*/;
 
    virtual void onGameModeChanged() /*override*/;
 
    virtual void onTick(int nTick, int maxTick) /*override*/;
 
    virtual void onInternetUpdate() /*override*/;
 
    virtual void onGameSessionReset() /*override*/;
 
    virtual void onLevelExit() /*override*/;
 
    virtual void onRequestResourceReload() /*override*/;
 
    virtual void onLowDiskSpace(bool const bSet, uint64) /*override*/;
 
    virtual void onOutOfDiskSpace(bool const bSet, uint64) /*override*/;
 
    virtual void onCriticalDiskError(bool const bSet, ::Core::LevelStorageState const& errorCode) /*override*/;
 
    virtual void onAppSuspended() /*override*/;
 
    virtual void onAppResumed() /*override*/;
 
    virtual void updateScreens() /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI explicit ServerInstance(::ServerInstanceArguments&& args);
 
    MCNAPI ::Bedrock::Threading::Async<bool> _postLevelInitialization(::ServerInstance::PostLevelArgs&& args);
 
#ifdef LL_PLAT_C
    MCNAPI void finishLoadingLinkedAssets(::ResourcePackManager& rpm);
#endif
 
    MCNAPI ::Bedrock::NonOwnerPointer<::Editor::IEditorManager> getEditorManager() const;
 
#ifdef LL_PLAT_C
    MCNAPI ::std::string getLevelId() const;
#endif
 
    MCAPI ::ServerInitialization::ServerInitResult initializeServer(::ServerInstanceInitArguments&& args);
 
    MCAPI void leaveGameSync();
 
    MCNAPI void onCriticalScriptError(::Connection::DisconnectFailReason clientReason, char const* logMessage);
 
    MCNAPI void queueForServerThread(::std::function<void()> command);
 
#ifdef LL_PLAT_C
    MCNAPI bool requestInGamePause(bool status);
 
    MCNAPI void setWorldSaveAndExitPackTelemetry(::std::vector<::WorldSaveAndExitPackTelemetryData> packs);
#endif
 
    MCAPI void startLeaveGame();
 
    MCNAPI void startServerThread();
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCNAPI static bool _useClientSideChunkGeneration(::LevelData* levelData);
 
    MCNAPI static ::brstd::move_only_function<bool(::ServerInstanceInitArguments::HostMultiplayerArguments&&) const>
    createHostMultiplayerCallback(
        ::ServerInstance&                  instance,
        ::NetworkServerConfig              networkServerConfig,
        ::KeyManager                       hostPublicKey,
        int                                maxChunkRadius,
        bool                               shouldAnnounce,
        ::ServerNetworkHandlerDependencies serverNetworkOptions
    );
 
    MCNAPI static ::brstd::move_only_function<
        ::std::unique_ptr<::ServerLevel>(::ServerInstanceInitArguments::CreateLevelArguments&&) const>
    createServerLevelCallback(::ServerInstance::CreateServerLevelOps&& ops);
 
#ifdef LL_PLAT_S
    MCNAPI static bool forceOffClientChunkGeneration(::LevelData& levelData);
#endif
    // NOLINTEND
 
public:
    // static variables
    // NOLINTBEGIN
    MCNAPI static ::std::string const& ASSET_EXTRACTION_ERROR();
 
    MCNAPI static ::std::string const& ENTITY_REGISTRY_CREATION_ERROR();
 
    MCNAPI static ::std::string const& FINAL_LEVEL_STORAGE_STATE_ERROR();
 
    MCNAPI static ::std::string const& HOST_MULTIPLAYER_ERROR();
 
    MCNAPI static ::std::string const& INITIAL_LEVEL_STORAGE_STATE_ERROR();
 
    MCNAPI static ::std::string const& LEVEL_STORAGE_CREATION_ERROR();
 
    MCNAPI static ::std::string const& PACK_SOURCE_LOADING_ERROR();
 
#ifdef LL_PLAT_C
    MCNAPI static ::std::string const& POST_INIT_ERROR();
#endif
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor(::ServerInstanceArguments&& args);
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCNAPI void $onLowMemory(::LowMemorySeverity);
 
    MCNAPI void $onLevelCorrupt();
 
    MCNAPI void $onGameModeChanged();
 
    MCNAPI void $onTick(int nTick, int maxTick);
 
    MCNAPI void $onInternetUpdate();
 
    MCNAPI void $onGameSessionReset();
 
    MCNAPI void $onLevelExit();
 
    MCNAPI void $onRequestResourceReload();
 
    MCNAPI void $onLowDiskSpace(bool const bSet, uint64);
 
    MCNAPI void $onOutOfDiskSpace(bool const bSet, uint64);
 
    MCNAPI void $onCriticalDiskError(bool const bSet, ::Core::LevelStorageState const& errorCode);
 
    MCNAPI void $onAppSuspended();
 
    MCNAPI void $onAppResumed();
 
    MCNAPI void $updateScreens();
 
 
    // NOLINTEND
};