d2/d36/src-client_2mc_2client_2game_2MinecraftGame_8h_source.html

#pragma once


#include "mc/_HeaderOutputPredefine.h"


// auto generated inclusion list

#include "mc/certificates/identity/edu/CredentialsObserver.h"

#include "mc/certificates/identity/edu/GenericCredentialsEvent.h"

#include "mc/client/game/DeferredTaskCategory.h"

#include "mc/client/game/IMinecraftGame.h"

#include "mc/client/game/IMultiPlayerServices.h"

#include "mc/client/game/SerialWorkList.h"

#include "mc/client/game/StartIntent.h"

#include "mc/client/game/local_server_launcher/ILocalServerLauncherImpl.h"

#include "mc/client/gui/GameEventNotification.h"

#include "mc/client/options/OptionsObserver.h"

#include "mc/client/renderer/texture/TextureAtlasStatus.h"

#include "mc/client/social/JoinGameStatus.h"

#include "mc/client/social/MultiplayerServiceIdentifier.h"

#include "mc/client/social/UserPlatformConnectionResult.h"

#include "mc/common/App.h"

#include "mc/common/SubClientId.h"

#include "mc/deps/application/LowMemorySeverity.h"

#include "mc/deps/core/file/PathBuffer.h"

#include "mc/deps/core/threading/Async.h"

#include "mc/deps/core/threading/DeferredTasksManager.h"

#include "mc/deps/core/utility/NonOwnerPointer.h"

#include "mc/deps/input/InputMode.h"

#include "mc/deps/input/PointerType.h"

#include "mc/events/IMinecraftEventing.h"

#include "mc/events/NetworkType.h"

#include "mc/locale/I18nObserver.h"

#include "mc/platform/MultiplayerLockedContext.h"

#include "mc/platform/brstd/move_only_function.h"

#include "mc/resources/ResourcePackListener.h"

#include "mc/sound/MusicRepeatMode.h"

#include "mc/world/level/LevelListener.h"


// auto generated forward declare list

// clang-format off

class ActiveDirectoryIdentity;

class ActorAnimationControllerGroup;

class ActorAnimationGroup;

class ActorResourceDefinitionGroup;

class AppSystemRegistry;

class BlockCullingGroup;

class ChunkSource;

class ClientInstance;

class ClientNetworkSystem;

class ClubsService;

class ContentAcquisition;

class ContentCatalogService;

class ContentIdentity;

class ContentLogFileEndPoint;

class CubemapBackgroundResources;

class DateManager;

class DeferredLighting;

class DevConsoleLogger;

class EDUSystems;

class EmoticonManager;

class EntityContext;

class ExternalContentManager;

class FileArchiver;

class FlightingService;

class FontHandle;

class GameModuleClient;

class GameRenderer;

class GatheringManager;

class GeometryGroup;

class GlobalResourcesCrashRecovery;

class GuiData;

class IApp;

class IClientDimensionExtensions;

class IClientInstance;

class IContentAccessibilityProvider;

class IContentKeyProvider;

class IContentManager;

class IContentTierManager;

class IDlcValidation;

class IEntitlementManager;

class IExternalServerFile;

class IGameModuleApp;

class IGameModuleShared;

class ILevelListCache;

class IMinecraftEventing;

class IOfferRepository;

class IResourcePackRepository;

class ISceneStack;

class ITextBoxController;

class IThirdPartyServerRepository;

class IUIDefRepository;

class IUIRepository;

class ItemRegistryRef;

class LatencyGraphDisplay;

class LevelDbEnv;

class LevelLoader;

class LevelSettings;

class LibraryRepository;

class LinkedAssetValidator;

class LocalPlayer;

class MarketplaceServicesManager;

class Minecraft;

class MinecraftGraphics;

class MinecraftInputHandler;

class MusicManager;

class NewPlayerSystem;

class Option;

class OptionRegistry;

class PackDownloadManager;

class PackManifest;

class PackManifestFactory;

class PackSourceFactory;

class ParticleEffectGroup;

class PersonaRepository;

class PersonaService;

class PixelCalc;

class Player;

class PlayerMessagingService;

class ProfanityContext;

class PushNotificationMessage;

class RealmsAPI;

class RenderControllerGroup;

class ResetCallbackObject;

class ResourceLoadManager;

class ResourcePackManager;

class ResourcePackStack;

class SceneFactory;

class ScreenshotRecorder;

class SeasonsRenderer;

class SerialWorkList;

class ServerInstance;

class ServerInstanceEventCoordinator;

class ServerNetworkHandler;

class ServiceDrivenImageRepository;

class ServicesManager;

class SkinRepository;

class SoundEngine;

class StoreCatalogRepository;

class SunsettingManager;

class TaskGroup;

class TextToIconMapper;

class TextureAtlas;

class Timer;

class TreatmentPackDownloadMonitor;

class TrialManager;

class UIMeasureStrategy;

class Vec3;

class WorldTemplateManager;

class WorldTransferAgent;

struct ActorUniqueID;

struct ControllerIDtoClientMap;

struct DimensionType;

struct ExperienceConnectionData;

struct ExternalWorldTransferActionFunc;

struct GameConnectionInfoEx;

struct LocalWorldTransferActionFunc;

struct MinecraftGameArguments;

struct PlayerJoinWorldContext;

struct RealmTransferActionFunc;

struct ScreenshotOptions;

namespace Automation { class AutomationClient; }

namespace Bedrock { class ActivationArguments; }

namespace Bedrock { class ScopeExit; }

namespace Bedrock::PubSub { class Subscription; }

namespace ClientBlobCache { class Cache; }

namespace ClientBlockPipeline { class SchematicsRepository; }

namespace Core { class FilePathManager; }

namespace Core { class Path; }

namespace LocalServerLauncher { class IGameInterface; }

namespace LocalServerLauncher { class IServerInstanceBuilder; }

namespace LocalServerLauncher { struct GameDependencies; }

namespace LocalServerLauncher { struct ServerInitData; }

namespace LocalServerLauncher { struct ServerLaunchResult; }

namespace LocalServerLauncher::Impl { struct AllDependencies; }

namespace OreUI { class DataProviderManager_DEPRECATED; }

namespace OreUI { class IResourceAllowList; }

namespace OreUI { class Router; }

namespace Parties { class PartySystem; }

namespace Progress { class ProgressTips; }

namespace Realms { class ContentService; }

namespace Realms { class GenericRequestServiceHandler; }

namespace Realms { class RealmsServices; }

namespace Realms { class RealmsSystem; }

namespace Realms { class SubscriptionService; }

namespace Realms { struct RealmId; }

namespace Realms { struct World; }

namespace Social { class GameConnectionInfo; }

namespace Social { class IUserManager; }

namespace Social { class MultiplayerGameInfo; }

namespace Social { class MultiplayerServiceManager; }

namespace Social { class PresenceManager; }

namespace Social { class SocialSystem; }

namespace Social { class User; }

namespace World { class WorldSystem; }

namespace dragon::framerenderer { struct DebugParameters; }

namespace edu::auth { struct CredentialsAcquired; }

namespace edu::auth { struct CredentialsRefreshSuccess; }

namespace edu::auth { struct CredsLost; }

namespace mce { class TextureGroup; }

namespace mce { class UUID; }

// clang-format on


class MinecraftGame : public ::IMinecraftGame,

                      public ::App,

                      public ::LevelListener,

                      public ::ResourcePackListener,

                      public ::OptionsObserver,

                      public ::edu::auth::CredentialsObserver,

                      public ::I18nObserver,

                      public ::IMultiPlayerServices,

                      public ::LocalServerLauncher::ILocalServerLauncherImpl {

public:

    // MinecraftGame inner types declare

    // clang-format off

    struct InitContext;

    struct TestCommandPublisher;

    struct FrameGapImpl;

    // clang-format on


    // MinecraftGame inner types define

    enum class SuspendState : int {

        Suspending = 0,

        Suspended  = 1,

        Resuming   = 2,

        Running    = 3,

    };


    enum class DeviceLostState : int {

        Valid      = 0,

        Lost       = 1,

        Recovering = 2,

    };


    enum class SurfaceState : int {

        Valid = 0,

        Lost  = 1,

    };


    enum class WorkList : uint64 {

        AppInitialize = 0,

        AppResume     = 1,

        AppDeviceLost = 2,

        Count         = 3,

    };


    struct InitContext {

    public:

        // member variables

        // NOLINTBEGIN

        ::ll::UntypedStorage<8, 16> mUnk1f2a2b;

        ::ll::UntypedStorage<8, 16> mUnkc9621b;

        // NOLINTEND


    public:

        // prevent constructor by default

        InitContext& operator=(InitContext const&);

        InitContext(InitContext const&);

        InitContext();

    };


    struct TestCommandPublisher {};


    struct FrameGapImpl {

    public:

        // member variables

        // NOLINTBEGIN

        ::ll::UntypedStorage<8, 8> mUnk2970b7;

        // NOLINTEND


    public:

        // prevent constructor by default

        FrameGapImpl& operator=(FrameGapImpl const&);

        FrameGapImpl(FrameGapImpl const&);

        FrameGapImpl();

    };


public:

    // member variables

    // NOLINTBEGIN

    ::ll::UntypedStorage<8, 16>  mUnk31cb40;

    ::ll::UntypedStorage<8, 64>  mUnk26362f;

    ::ll::UntypedStorage<8, 8>   mUnk5833c3;

    ::ll::UntypedStorage<8, 8>   mUnk707e20;

    ::ll::UntypedStorage<8, 8>   mUnk77bae9;

    ::ll::UntypedStorage<8, 8>   mUnk39dbf1;

    ::ll::UntypedStorage<8, 8>   mUnkb9a1e2;

    ::ll::UntypedStorage<8, 8>   mUnka617fc;

    ::ll::UntypedStorage<8, 8>   mUnk1a8ba7;

    ::ll::UntypedStorage<8, 8>   mUnk8c1a51;

    ::ll::UntypedStorage<8, 8>   mUnkdcd0a8;

    ::ll::UntypedStorage<8, 8>   mUnk27a9f1;

    ::ll::UntypedStorage<8, 8>   mUnk6449d7;

    ::ll::UntypedStorage<8, 8>   mUnk6585d8;

    ::ll::UntypedStorage<8, 8>   mUnk18dd91;

    ::ll::UntypedStorage<8, 8>   mUnke812cf;

    ::ll::UntypedStorage<8, 8>   mUnk102e50;

    ::ll::UntypedStorage<8, 8>   mUnkd0fa73;

    ::ll::UntypedStorage<8, 8>   mUnk30cf6e;

    ::ll::UntypedStorage<1, 1>   mUnk73dd14;

    ::ll::UntypedStorage<8, 64>  mUnkc4eefd;

    ::ll::UntypedStorage<8, 64>  mUnk4d9a8c;

    ::ll::UntypedStorage<8, 16>  mUnke052b6;

    ::ll::UntypedStorage<8, 8>   mUnk79ddba;

    ::ll::UntypedStorage<8, 8>   mUnkf926be;

    ::ll::UntypedStorage<8, 8>   mUnk37afa1;

    ::ll::UntypedStorage<8, 8>   mUnk68dc1e;

    ::ll::UntypedStorage<8, 16>  mUnka2869f;

    ::ll::UntypedStorage<8, 8>   mUnkde38fc;

    ::ll::UntypedStorage<8, 8>   mUnk9a183a;

    ::ll::UntypedStorage<8, 8>   mUnk46def3;

    ::ll::UntypedStorage<8, 8>   mUnkc587de;

    ::ll::UntypedStorage<8, 8>   mUnk4a17b1;

    ::ll::UntypedStorage<8, 8>   mUnk812bde;

    ::ll::UntypedStorage<8, 32>  mUnkb501e6;

    ::ll::UntypedStorage<8, 8>   mUnk8f8079;

    ::ll::UntypedStorage<8, 8>   mUnkcd6826;

    ::ll::UntypedStorage<8, 16>  mUnk5849e3;

    ::ll::UntypedStorage<8, 16>  mUnk336443;

    ::ll::UntypedStorage<1, 1>   mUnkb6d61e;

    ::ll::UntypedStorage<8, 16>  mUnkd61d74;

    ::ll::UntypedStorage<4, 4>   mUnkda7647;

    ::ll::UntypedStorage<4, 4>   mUnk730c95;

    ::ll::UntypedStorage<1, 1>   mUnk391e21;

    ::ll::UntypedStorage<4, 4>   mUnk859534;

    ::ll::UntypedStorage<8, 8>   mUnk8b857f;

    ::ll::UntypedStorage<8, 8>   mUnkeb3d6b;

    ::ll::UntypedStorage<8, 16>  mUnk8598e2;

    ::ll::UntypedStorage<8, 32>  mUnk29d8a4;

    ::ll::UntypedStorage<8, 16>  mUnk8120e2;

    ::ll::UntypedStorage<1, 1>   mUnkbf9e1f;

    ::ll::UntypedStorage<1, 1>   mUnkf1c360;

    ::ll::UntypedStorage<8, 8>   mUnk596107;

    ::ll::UntypedStorage<8, 8>   mUnkcc0494;

    ::ll::UntypedStorage<8, 8>   mUnkc32677;

    ::ll::UntypedStorage<8, 8>   mUnkfb38cb;

    ::ll::UntypedStorage<1, 1>   mUnk549470;

    ::ll::UntypedStorage<4, 4>   mUnkdaeaa4;

    ::ll::UntypedStorage<4, 4>   mUnk978a98;

    ::ll::UntypedStorage<1, 1>   mUnk7186c4;

    ::ll::UntypedStorage<1, 1>   mUnkeeb15c;

    ::ll::UntypedStorage<1, 1>   mUnk21487c;

    ::ll::UntypedStorage<1, 1>   mUnk7f0094;

    ::ll::UntypedStorage<1, 1>   mUnk1f7e9d;

    ::ll::UntypedStorage<1, 1>   mUnk71b5c7;

    ::ll::UntypedStorage<8, 32>  mUnk570845;

    ::ll::UntypedStorage<4, 4>   mUnk785de7;

    ::ll::UntypedStorage<8, 408> mUnke04be5;

    ::ll::UntypedStorage<1, 1>   mUnk19eccc;

    ::ll::UntypedStorage<4, 4>   mUnk97e7f8;

    ::ll::UntypedStorage<8, 16>  mUnk61cb9f;

    ::ll::UntypedStorage<1, 1>   mUnk3ebcf8;

    ::ll::UntypedStorage<1, 1>   mUnk39e2bc;

    ::ll::UntypedStorage<1, 1>   mUnked6187;

    ::ll::UntypedStorage<1, 1>   mUnk9e21e6;

    ::ll::UntypedStorage<1, 1>   mUnkfed6cd;

    ::ll::UntypedStorage<1, 1>   mUnk41cbb8;

    ::ll::UntypedStorage<4, 4>   mUnk9b7c5f;

    ::ll::UntypedStorage<1, 1>   mUnkc8c391;

    ::ll::UntypedStorage<1, 1>   mUnka7b938;

    ::ll::UntypedStorage<1, 1>   mUnk5907ad;

    ::ll::UntypedStorage<1, 1>   mUnk6f26ef;

    ::ll::UntypedStorage<8, 56>  mUnk2fd9a7;

    ::ll::UntypedStorage<8, 8>   mUnke44711;

    ::ll::UntypedStorage<8, 80>  mUnk27b53a;

    ::ll::UntypedStorage<8, 8>   mUnk3ee8f3;

    ::ll::UntypedStorage<8, 16>  mUnk5d44d0;

    ::ll::UntypedStorage<1, 1>   mUnk64a982;

    ::ll::UntypedStorage<1, 1>   mUnk456e9b;

    ::ll::UntypedStorage<1, 1>   mUnkd57772;

    ::ll::UntypedStorage<1, 1>   mUnk780cef;

    ::ll::UntypedStorage<8, 8>   mUnkbbeca7;

    ::ll::UntypedStorage<8, 8>   mUnk523cee;

    ::ll::UntypedStorage<8, 40>  mUnka60eca;

    ::ll::UntypedStorage<8, 32>  mUnk78c4dd;

    ::ll::UntypedStorage<1, 1>   mUnka2f794;

    ::ll::UntypedStorage<1, 1>   mUnk90b4e5;

    ::ll::UntypedStorage<8, 16>  mUnk3fa9bf;

    ::ll::UntypedStorage<8, 8>   mUnkfa9b14;

    ::ll::UntypedStorage<8, 8>   mUnk975fa0;

    ::ll::UntypedStorage<8, 8>   mUnkc95a9f;

    ::ll::UntypedStorage<8, 8>   mUnkdef9e3;

    ::ll::UntypedStorage<8, 16>  mUnk44f519;

    ::ll::UntypedStorage<8, 8>   mUnka426aa;

    ::ll::UntypedStorage<8, 16>  mUnkd412af;

    ::ll::UntypedStorage<8, 16>  mUnk333c36;

    ::ll::UntypedStorage<8, 8>   mUnkab5b49;

    ::ll::UntypedStorage<8, 8>   mUnk2d070e;

    ::ll::UntypedStorage<8, 8>   mUnkffc4a2;

    ::ll::UntypedStorage<8, 8>   mUnk87a54d;

    ::ll::UntypedStorage<8, 8>   mUnk80cd0e;

    ::ll::UntypedStorage<8, 8>   mUnk692520;

    ::ll::UntypedStorage<8, 8>   mUnkb8db74;

    ::ll::UntypedStorage<8, 8>   mUnkb69251;

    ::ll::UntypedStorage<8, 8>   mUnk138dbc;

    ::ll::UntypedStorage<8, 8>   mUnk125782;

    ::ll::UntypedStorage<8, 8>   mUnk116bf2;

    ::ll::UntypedStorage<8, 8>   mUnkf25a9b;

    ::ll::UntypedStorage<8, 8>   mUnk75183c;

    ::ll::UntypedStorage<8, 8>   mUnk984c5b;

    ::ll::UntypedStorage<8, 16>  mUnk795ad2;

    ::ll::UntypedStorage<8, 8>   mUnkd9da77;

    ::ll::UntypedStorage<8, 16>  mUnkcc1ee6;

    ::ll::UntypedStorage<8, 8>   mUnk291774;

    ::ll::UntypedStorage<8, 8>   mUnk8f0421;

    ::ll::UntypedStorage<8, 16>  mUnk9ac038;

    ::ll::UntypedStorage<8, 64>  mUnk33501c;

    ::ll::UntypedStorage<8, 8>   mUnk95a9d2;

    ::ll::UntypedStorage<8, 8>   mUnk78243e;

    ::ll::UntypedStorage<8, 8>   mUnkb0966b;

    ::ll::UntypedStorage<8, 8>   mUnke4850d;

    ::ll::UntypedStorage<8, 8>   mUnk949250;

    ::ll::UntypedStorage<8, 8>   mUnk94c9dc;

    ::ll::UntypedStorage<8, 8>   mUnk56924c;

    ::ll::UntypedStorage<8, 8>   mUnk7c70a9;

    ::ll::UntypedStorage<8, 8>   mUnka6f4b7;

    ::ll::UntypedStorage<8, 8>   mUnk4c8c20;

    ::ll::UntypedStorage<8, 16>  mUnkde6f9f;

    ::ll::UntypedStorage<8, 16>  mUnk51caaa;

    ::ll::UntypedStorage<8, 16>  mUnk88dd50;

    ::ll::UntypedStorage<8, 8>   mUnkf13f9f;

    ::ll::UntypedStorage<8, 8>   mUnk46f031;

    ::ll::UntypedStorage<8, 8>   mUnkad7e31;

    ::ll::UntypedStorage<8, 8>   mUnk41ce20;

    ::ll::UntypedStorage<8, 8>   mUnk5cf030;

    ::ll::UntypedStorage<8, 8>   mUnkb9503e;

    ::ll::UntypedStorage<8, 8>   mUnk9c023b;

    ::ll::UntypedStorage<8, 8>   mUnk5315ca;

    ::ll::UntypedStorage<8, 8>   mUnk276668;

    ::ll::UntypedStorage<8, 8>   mUnk3ec43f;

    ::ll::UntypedStorage<8, 8>   mUnkb5e444;

    ::ll::UntypedStorage<8, 16>  mUnk36c9d2;

    ::ll::UntypedStorage<8, 8>   mUnkeee60b;

    ::ll::UntypedStorage<8, 8>   mUnkc1e9f3;

    ::ll::UntypedStorage<8, 48>  mUnka02940;

    ::ll::UntypedStorage<8, 16>  mUnk748223;

    ::ll::UntypedStorage<8, 16>  mUnkec6beb;

    ::ll::UntypedStorage<8, 8>   mUnk55dcf8;

    ::ll::UntypedStorage<8, 8>   mUnk585275;

    ::ll::UntypedStorage<8, 16>  mUnk4877d7;

    ::ll::UntypedStorage<8, 8>   mUnkd72bcd;

    ::ll::UntypedStorage<8, 8>   mUnk6c5fec;

    ::ll::UntypedStorage<8, 16>  mUnk2b5c1a;

    ::ll::UntypedStorage<8, 16>  mUnkdaad93;

    ::ll::UntypedStorage<8, 8>   mUnk2a83b2;

    ::ll::UntypedStorage<8, 8>   mUnkd10826;

    ::ll::UntypedStorage<8, 8>   mUnk64ddee;

    ::ll::UntypedStorage<8, 64>  mUnkd24a7a;

    ::ll::UntypedStorage<8, 8>   mUnkec79fd;

    ::ll::UntypedStorage<8, 8>   mUnk74222f;

    ::ll::UntypedStorage<8, 8>   mUnk468478;

    ::ll::UntypedStorage<8, 8>   mUnkea13b7;

    ::ll::UntypedStorage<8, 744> mUnk9947a0;

    ::ll::UntypedStorage<8, 16>  mUnkbf42d0;

    ::ll::UntypedStorage<8, 16>  mUnk469d3c;

    ::ll::UntypedStorage<8, 8>   mUnkf245c7;

    ::ll::UntypedStorage<8, 64>  mUnk30b039;

    ::ll::UntypedStorage<8, 8>   mUnk6906a6;

    ::ll::UntypedStorage<8, 8>   mUnka198d7;

    ::ll::UntypedStorage<8, 64>  mUnk63da8b;

    ::ll::UntypedStorage<8, 64>  mUnk19e15f;

    ::ll::UntypedStorage<8, 8>   mUnk68bd55;

    ::ll::UntypedStorage<8, 8>   mUnkd56e6e;

    ::ll::UntypedStorage<8, 64>  mUnk6331f9;

    ::ll::UntypedStorage<8, 64>  mUnkfb3c1e;

    ::ll::UntypedStorage<8, 8>   mUnkb4aa43;

    ::ll::UntypedStorage<8, 8>   mUnkfd4a2e;

    ::ll::UntypedStorage<8, 8>   mUnk4764de;

    ::ll::UntypedStorage<8, 8>   mUnk2db41b;

    ::ll::UntypedStorage<8, 64>  mUnk4282e8;

    ::ll::UntypedStorage<8, 8>   mUnk313b8d;

    ::ll::UntypedStorage<8, 16>  mUnka4d1d6;

    ::ll::UntypedStorage<8, 8>   mUnkb98e22;

    ::ll::UntypedStorage<8, 64>  mUnk358786;

    ::ll::UntypedStorage<8, 8>   mUnk633776;

    ::ll::UntypedStorage<8, 8>   mUnkc61c3a;

    ::ll::UntypedStorage<8, 8>   mUnk910337;

    ::ll::UntypedStorage<8, 8>   mUnkd6ff96;

    ::ll::UntypedStorage<8, 8>   mUnk51e772;

    ::ll::UntypedStorage<8, 8>   mUnkf2c3d8;

    ::ll::UntypedStorage<8, 64>  mUnkc5fc6f;

    ::ll::UntypedStorage<8, 8>   mUnk7e94f8;

    ::ll::UntypedStorage<8, 8>   mUnkf60a71;

    ::ll::UntypedStorage<8, 16>  mUnk5f5935;

    ::ll::UntypedStorage<8, 8>   mUnkd12853;

    ::ll::UntypedStorage<8, 16>  mUnk9f4932;

    ::ll::UntypedStorage<8, 8>   mUnk93ccfd;

    ::ll::UntypedStorage<1, 1>   mUnk4d836f;

    ::ll::UntypedStorage<8, 16>  mUnk626810;

    ::ll::UntypedStorage<8, 8>   mUnkce7b8c;

    ::ll::UntypedStorage<8, 8>   mUnka05418;

    ::ll::UntypedStorage<8, 16>  mUnkfb7cce;

    ::ll::UntypedStorage<8, 8>   mUnk17a5e5;

    ::ll::UntypedStorage<8, 8>   mUnk1d082c;

    ::ll::UntypedStorage<8, 8>   mUnk721c07;

    ::ll::UntypedStorage<8, 8>   mUnk75c011;

    ::ll::UntypedStorage<8, 8>   mUnk662066;

    ::ll::UntypedStorage<8, 8>   mUnka63939;

    ::ll::UntypedStorage<8, 8>   mUnkd68cd6;

    ::ll::UntypedStorage<8, 16>  mUnkd0c917;

    ::ll::UntypedStorage<8, 8>   mUnka64c85;

    ::ll::UntypedStorage<8, 8>   mUnk31922c;

    ::ll::UntypedStorage<8, 8>   mUnkb92250;

    ::ll::UntypedStorage<8, 8>   mUnkc46d8a;

    ::ll::UntypedStorage<8, 64>  mUnk391b07;

    ::ll::UntypedStorage<8, 80>  mUnk36d9f1;

    ::ll::UntypedStorage<8, 80>  mUnk2de6a0;

    ::ll::UntypedStorage<8, 80>  mUnkc7328a;

    ::ll::UntypedStorage<8, 80>  mUnk880945;

    ::ll::UntypedStorage<8, 80>  mUnk26d14c;

    ::ll::UntypedStorage<8, 8>   mUnk3dc5d4;

    ::ll::UntypedStorage<8, 8>   mUnk6622a0;

    ::ll::UntypedStorage<8, 16>  mUnke27718;

    ::ll::UntypedStorage<8, 16>  mUnk9599c5;

    ::ll::UntypedStorage<8, 8>   mUnk1498bc;

    ::ll::UntypedStorage<8, 16>  mUnkc84d4d;

    ::ll::UntypedStorage<8, 8>   mUnk7757ed;

    ::ll::UntypedStorage<8, 8>   mUnk8b5a69;

    ::ll::UntypedStorage<8, 16>  mUnk8a114f;

    ::ll::UntypedStorage<8, 8>   mUnk2c648f;

    ::ll::UntypedStorage<8, 8>   mUnkef66f4;

    ::ll::UntypedStorage<8, 8>   mUnk5cb7cc;

    ::ll::UntypedStorage<8, 432> mUnke5c301;

    ::ll::UntypedStorage<8, 8>   mUnkd18639;

    ::ll::UntypedStorage<8, 8>   mUnk67d5dd;

    ::ll::UntypedStorage<8, 8>   mUnkc0bd78;

    ::ll::UntypedStorage<8, 8>   mUnk8ac119;

    ::ll::UntypedStorage<8, 16>  mUnkddfaa0;

    ::ll::UntypedStorage<8, 8>   mUnk20b98a;

    ::ll::UntypedStorage<8, 8>   mUnkcb59ec;

    ::ll::UntypedStorage<8, 8>   mUnk82663e;

    ::ll::UntypedStorage<8, 8>   mUnkb6a170;

    ::ll::UntypedStorage<8, 8>   mUnk8673bc;

    ::ll::UntypedStorage<8, 8>   mUnk1187d6;

    ::ll::UntypedStorage<8, 8>   mUnk807b24;

    ::ll::UntypedStorage<8, 8>   mUnke45c86;

    ::ll::UntypedStorage<8, 8>   mUnk1cf921;

    ::ll::UntypedStorage<8, 8>   mUnk70c996;

    ::ll::UntypedStorage<8, 8>   mUnk89400e;

    ::ll::UntypedStorage<8, 8>   mUnk946503;

    ::ll::UntypedStorage<8, 8>   mUnk781ed2;

    ::ll::UntypedStorage<8, 8>   mUnk871dc6;

    ::ll::UntypedStorage<8, 8>   mUnkf2f2ba;

    ::ll::UntypedStorage<8, 8>   mUnk4daba7;

    ::ll::UntypedStorage<8, 8>   mUnkd4beeb;

    ::ll::UntypedStorage<8, 8>   mUnkde4441;

    ::ll::UntypedStorage<8, 8>   mUnk8f12bc;

    ::ll::UntypedStorage<8, 8>   mUnkc2e1c6;

    ::ll::UntypedStorage<8, 8>   mUnk3ed686;

    ::ll::UntypedStorage<8, 8>   mUnk45b4b1;

    ::ll::UntypedStorage<8, 8>   mUnk777677;

    ::ll::UntypedStorage<8, 8>   mUnk1d6e6b;

    ::ll::UntypedStorage<8, 8>   mUnk7fca88;

    ::ll::UntypedStorage<8, 8>   mUnk71d6b7;

    ::ll::UntypedStorage<8, 8>   mUnk8d4567;

    ::ll::UntypedStorage<8, 8>   mUnkfdb8ca;

    ::ll::UntypedStorage<8, 8>   mUnkf68a87;

    ::ll::UntypedStorage<8, 8>   mUnk45501b;

    ::ll::UntypedStorage<8, 8>   mUnk10c987;

    ::ll::UntypedStorage<8, 48>  mUnk3703bb;

    ::ll::UntypedStorage<8, 8>   mUnkdd5b99;

    ::ll::UntypedStorage<8, 16>  mUnk1c3779;

    ::ll::UntypedStorage<8, 16>  mUnk4b4e23;

    ::ll::UntypedStorage<8, 24>  mUnk698964;

    ::ll::UntypedStorage<8, 24>  mUnk8d1118;

    ::ll::UntypedStorage<8, 16>  mUnk99fad5;

    ::ll::UntypedStorage<8, 24>  mUnk4f11c0;

    ::ll::UntypedStorage<8, 24>  mUnk205f41;

    ::ll::UntypedStorage<8, 8>   mUnk952a89;

    ::ll::UntypedStorage<8, 8>   mUnk2ac62b;

    ::ll::UntypedStorage<8, 8>   mUnk185e8d;

    ::ll::UntypedStorage<8, 8>   mUnk94b524;

    ::ll::UntypedStorage<8, 8>   mUnk308f25;

    ::ll::UntypedStorage<8, 8>   mUnk5dd8f3;

    ::ll::UntypedStorage<8, 8>   mUnkceb4ab;

    ::ll::UntypedStorage<8, 8>   mUnk50a24d;

    ::ll::UntypedStorage<8, 16>  mUnk976824;

    ::ll::UntypedStorage<8, 8>   mUnkcd32cf;

    ::ll::UntypedStorage<8, 8>   mUnk32d240;

    ::ll::UntypedStorage<8, 16>  mUnkaa8c49;

    ::ll::UntypedStorage<8, 680> mUnkbfced1;

    ::ll::UntypedStorage<8, 16>  mUnka3a452;

    ::ll::UntypedStorage<8, 8>   mUnk7f0a19;

    ::ll::UntypedStorage<8, 16>  mUnk968b3f;

    ::ll::UntypedStorage<8, 8>   mUnk67f34e;

    ::ll::UntypedStorage<8, 8>   mUnkc456b9;

    ::ll::UntypedStorage<8, 8>   mUnk804e62;

    ::ll::UntypedStorage<8, 8>   mUnk92ee4c;

    ::ll::UntypedStorage<8, 8>   mUnke4e7c9;

    ::ll::UntypedStorage<8, 8>   mUnk5e4634;

    ::ll::UntypedStorage<8, 64>  mUnk12c89f;

    ::ll::UntypedStorage<8, 16>  mUnk42b15f;

    ::ll::UntypedStorage<8, 16>  mUnk48c2a3;

    ::ll::UntypedStorage<8, 16>  mUnka8e328;

    ::ll::UntypedStorage<8, 24>  mUnkba1560;

    ::ll::UntypedStorage<8, 16>  mUnk3bcf80;

    ::ll::UntypedStorage<8, 16>  mUnka14281;

    ::ll::UntypedStorage<1, 1>   mUnkd46ea8;

    ::ll::UntypedStorage<8, 8>   mUnk205ada;

    ::ll::UntypedStorage<8, 16>  mUnk41bdf3;

    ::ll::UntypedStorage<8, 16>  mUnkad2805;

    ::ll::UntypedStorage<8, 16>  mUnk6b22bf;

    ::ll::UntypedStorage<8, 64>  mUnkf160e9;

    ::ll::UntypedStorage<8, 64>  mUnk19d968;

    // NOLINTEND


public:

    // prevent constructor by default

    MinecraftGame& operator=(MinecraftGame const&);

    MinecraftGame(MinecraftGame const&);

    MinecraftGame();


public:

    // virtual functions

    // NOLINTBEGIN

    virtual void initialize() /*override*/;


    virtual ~MinecraftGame() /*override*/;


    virtual bool stop() /*override*/;


    virtual void processActivationArguments(::Bedrock::ActivationArguments const& args) /*override*/;


    virtual void audioEngineOn() /*override*/;


    virtual void audioEngineOff() /*override*/;


    virtual void update() /*override*/;


    virtual void play(::std::string const& name, ::Vec3 const& pos, float volume, float pitch) /*override*/;


    virtual void playUI(::std::string const& name, float volume, float pitch) /*override*/;


    virtual void stopSound(::std::string const& name) /*override*/;


    virtual void stopSounds() /*override*/;


    virtual void setUISizeAndScale(int w, int h, float forcedGuiScale) /*override*/;


    virtual void setRenderingSize(int w, int h) /*override*/;


    virtual void recalculateScene() /*override*/;


    virtual void setSmoothFontStyle() /*override*/;


    virtual void setUIFontStyle() /*override*/;


    virtual ::Bedrock::Threading::Async<void> startLocalServerAsync(

        ::std::string const&     levelId,

        ::std::string const&     levelName,

        ::ContentIdentity const& premiumTemplateContentIdentity,

        ::LevelSettings const&   settings,

        ::StartIntent            startIntent

    ) /*override*/;


    virtual void createAndUploadWorldToRealm(

        ::std::string const&                   levelId,

        ::std::string const&                   levelName,

        ::ContentIdentity const&               premiumTemplateContentIdentity,

        ::LevelSettings const&                 settings,

        ::Realms::World                        world,

        ::std::function<void(::Realms::World)> callback

    ) /*override*/;


    virtual bool canStartLocalServer() const /*override*/;


    virtual bool isAudioInitialized() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::SoundEngine> getSoundEngine() const /*override*/;


    virtual ::MusicManager const* getMusicManager() const /*override*/;


    virtual ::MusicManager* getMusicManagerNonConst() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ITextBoxController> getTextBoxController() /*override*/;


    virtual void onLowMemory(::LowMemorySeverity) /*override*/;


    virtual void onAppFocusLost() /*override*/;


    virtual void onAppFocusGained() /*override*/;


    virtual void onAppPaused() /*override*/;


    virtual void onAppUnpaused() /*override*/;


    virtual void setReconnectionCookie(

        ::std::optional<::std::variant<

            ::GameConnectionInfoEx,

            ::Social::MultiplayerGameInfo,

            ::ExperienceConnectionData,

            ::Realms::RealmId>> const& reconnectCookie

    ) /*override*/;


    virtual ::std::optional<::std::variant<

        ::GameConnectionInfoEx,

        ::Social::MultiplayerGameInfo,

        ::ExperienceConnectionData,

        ::Realms::RealmId>>

    getReconnectionCookie() /*override*/;


    virtual void onAppPreSuspended() /*override*/;


    virtual void onAppSuspended() /*override*/;


    virtual void onAppResumed() /*override*/;


    virtual void onDeviceLost() /*override*/;


    virtual void onAppSurfaceCreated() /*override*/;


    virtual void onAppSurfaceDestroyed() /*override*/;


    virtual void openPauseMenu() /*override*/;


    virtual bool hasNetworkPrivileges(bool onlyWifiAllowed) /*override*/;


    virtual void onPlayerLoaded(::IClientInstance& client, ::Player& player) /*override*/;


    virtual void onDimensionChanged() /*override*/;


    virtual void setDisableInputForAllOtherClients(int id, bool disableStatus) /*override*/;


    virtual void onGameEventNotification(::ui::GameEventNotification notification) /*override*/;


    virtual void playerListChanged() /*override*/;


    virtual void onLevelDestruction(::std::string const& levelId) /*override*/;


    virtual void setWorldTransferAction(

        ::std::variant<

            ::LocalWorldTransferActionFunc,

            ::ExternalWorldTransferActionFunc,

            ::RealmTransferActionFunc,

            ::std::monostate>&& worldTransferAction

    ) /*override*/;


    virtual ::std::variant<

        ::LocalWorldTransferActionFunc,

        ::ExternalWorldTransferActionFunc,

        ::RealmTransferActionFunc,

        ::std::monostate> const&

    getWorldTransferAction() const /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::WorldTransferAgent> const getWorldTransferAgent() const /*override*/;


    virtual void setIsWorldTransferInProgress(bool isWorldTransferInProgress) /*override*/;


    virtual bool isWorldTransferInProgress() const /*override*/;


    virtual void setResetCallbackObject(::ResetCallbackObject* obj) /*override*/;


    virtual void requestLeaveGame(bool switchScreen, bool sync) /*override*/;


    virtual void requestLeaveThenJoinFriendsWorld(::std::string_view serverId) /*override*/;


    virtual void startLeaveGame() /*override*/;


    virtual bool isLeaveGameDone() const /*override*/;


    virtual void destroyGame() /*override*/;


    virtual void setupCommandParser(::IClientInstance& client) /*override*/;


    virtual void onClientCreatedLevel(::IClientInstance& client) /*override*/;


    virtual ::GameRenderer& getGameRenderer() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IUIDefRepository> getUIDefRepo() const /*override*/;


    virtual void joinRealmsGame(

        ::Realms::World const&              realm,

        ::Social::GameConnectionInfo const& gameConnection,

        ::PlayerJoinWorldContext            context

    ) /*override*/;


    virtual void joinRealmFromInvite(::Realms::World const& world) /*override*/;


    virtual void joinRealmFromConnectLink(::Realms::World const& world, ::PlayerJoinWorldContext context) /*override*/;


    virtual void setRealmsLoadingLink(bool state) /*override*/;


    virtual void joinRealm(

        ::Realms::World const&                    world,

        ::IMinecraftEventing::RealmConnectionFlow telemetryEventingConnectionFlow,

        ::PlayerJoinWorldContext                  context

    ) /*override*/;


    virtual ::Bedrock::Threading::Async<void>

    joinMultiplayerGame(::Social::MultiplayerGameInfo const& gameInfo, ::PlayerJoinWorldContext context) /*override*/;


    virtual void joinMultiplayerWithAddress(

        ::Social::GameConnectionInfo gameConnection,

        bool                         joiningLocalServer,

        ::std::string const&         serverName,

        ::std::string const&         worldName,

        ::NetworkType                networkTypeOverride,

        ::PlayerJoinWorldContext     context

    ) /*override*/;


    virtual void joinRemoteServerWithAddress(

        ::Social::GameConnectionInfo gameConnection,

        ::std::string const&         serverName,

        ::std::string const&         worldName,

        ::NetworkType                networkTypeOverride,

        ::PlayerJoinWorldContext     context

    ) /*override*/;


    virtual bool isLocalPlayer(::ActorUniqueID const& id) const /*override*/;


    virtual void setLeaveGameInProgressAsReadyToContinue() /*override*/;


    virtual bool isPrimaryClientInstanceReady() const /*override*/;


    virtual void ensureAllClientsAreLeaving() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IClientInstance> getPrimaryClientInstance() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IClientInstance const> getPrimaryClientInstance() const /*override*/;


    virtual ::ItemRegistryRef getClientItemRegistry() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem> getNewPlayerSystem() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem const> getNewPlayerSystem() const /*override*/;


    virtual ::std::map<::SubClientId, ::std::shared_ptr<::IClientInstance>> const& getClientInstanceMap() const

        /*override*/;


    virtual ::std::shared_ptr<::IClientInstance> tryGetClientInstanceFromPlayerUUID(::mce::UUID const& playerId) const

        /*override*/;


    virtual uint getUIRenderClientMask() const /*override*/;


    virtual uint64 getClientInstanceCount() const /*override*/;


    virtual void forEachClientInstance(::std::function<void(::IClientInstance&)> callback) /*override*/;


    virtual ::LocalPlayer* getPrimaryLocalPlayer() /*override*/;


    virtual ::LocalPlayer const* getPrimaryLocalPlayer() const /*override*/;


    virtual bool isPrimaryLevelCrossPlatformMultiplayer() const /*override*/;


    virtual bool isPrimaryLevelMultiplayer() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::GuiData> getPrimaryGuiData() /*override*/;


    virtual ::std::shared_ptr<::OptionRegistry> getPrimaryUserOptions() /*override*/;


    virtual ::std::shared_ptr<::OptionRegistry const> getPrimaryUserOptions() const /*override*/;


    virtual bool isPrimaryUserSigninInProgress() const /*override*/;


    virtual void resetInput() /*override*/;


    virtual ::PixelCalc const& getDpadScale() const /*override*/;


    virtual void setKeyboardForcedHeight(float height, bool isShowSignal) /*override*/;


    virtual bool canActivateKeyboard() /*override*/;


    virtual void reloadAnimationAndGeometryData(bool sync) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::GeometryGroup> getGeometryGroup() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::BlockCullingGroup> getBlockCullingGroup() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ClientBlockPipeline::SchematicsRepository> getSchematicsRepository() const

        /*override*/;


    virtual ::ParticleEffectGroup& getParticleEffectGroup() const /*override*/;


    virtual ::DeferredLighting& getDeferredLighting() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ContentAcquisition> getContentAcquisition() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IOfferRepository> getOfferRepository() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::TrialManager> getTrialManager() const /*override*/;


    virtual bool isTrialManagerInitialized() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::PersonaService> getPersonaService() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::GatheringManager> getGatheringManager() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ContentCatalogService> getContentCatalogService() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::StoreCatalogRepository> getStoreCatalog() const /*override*/;


    virtual ::ServiceDrivenImageRepository& getServiceImageRepository() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::LibraryRepository> getLibraryRepository() const /*override*/;


    virtual ::std::shared_ptr<::ActorAnimationGroup> getActorAnimationGroup() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationControllerGroup> getActorAnimationControllerGroup() const

        /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository const> getThirdPartyServerRepository() const

        /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository> getThirdPartyServerRepository() /*override*/;


    virtual ::std::shared_ptr<::SkinRepository> getSkinRepository() const /*override*/;


    virtual ::PersonaRepository& getPersonaRepository() const /*override*/;


    virtual ::MarketplaceServicesManager& getMarketplaceServicesManager() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::WorldTemplateManager> getWorldTemplateManager() const /*override*/;


    virtual ::World::WorldSystem& getWorldSystem() const /*override*/;


    virtual bool isWorldSystemReady() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsSystem> getRealmsSystem() const /*override*/;


    virtual ::Social::SocialSystem& getSocialSystem() const /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::Parties::PartySystem> getPartySystem() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Progress::ProgressTips> getUIProgressTips() const /*override*/;


    virtual ::IResourcePackRepository& getResourcePackRepository() const /*override*/;


    virtual ::ResourcePackManager& getResourcePackManager() const /*override*/;


    virtual ::ResourcePackManager& getServerResourcePackManager() /*override*/;


    virtual ::PackManifestFactory& getPackManifestFactory() /*override*/;


    virtual ::PlayerMessagingService& getPlayerMessagingService() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentKeyProvider const> getKeyProvider() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider const> getAccessibilityProvider() const

        /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider> getAccessibilityProvider() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentTierManager const> getContentTierManager() const /*override*/;


    virtual ::PackSourceFactory& getPackSourceFactory() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ResourceLoadManager> getResourceLoadManager() /*override*/;


    virtual ::ILevelListCache& getLevelListCache() /*override*/;


    virtual bool hasAllValidCrossPlatformSkin() const /*override*/;


    virtual ::PackDownloadManager& getPackDownloadManager() /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> getLinkedAssetValidator() const /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> getLinkedAssetValidator() /*override*/;


    virtual bool isMultiplayerServiceManagerReady() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::MultiplayerServiceManager> getMultiplayerServiceManager() const

        /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::IUserManager> getUserManager() const /*override*/;


    virtual ::IMinecraftEventing& getEventing() const /*override*/;


    virtual ::ServerInstance* getServerInstance() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerInstance> getServerInstanceNonOwnPtr() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ClientNetworkSystem> getClientNetworkSystemPtr() /*override*/;


    virtual ::ClientNetworkSystem& getClientNetworkSystem() /*override*/;


    virtual ::ClientNetworkSystem const& getClientNetworkSystem() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ActiveDirectoryIdentity> getActiveDirectoryIdentity() /*override*/;


    virtual void clearCache() /*override*/;


    virtual void releaseClientSubId(::SubClientId subid) /*override*/;


    virtual bool isStartingGame() const /*override*/;


    virtual bool isSplitscreenJoinEnabled() const /*override*/;


    virtual bool canAddSplitscreenSubClient(int controllerId) const /*override*/;


    virtual void addSubClientInstanceAndAssociateToUser(int controllerId) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ControllerIDtoClientMap> retrieveCIDToClientMap() /*override*/;


    virtual ::Bedrock::PubSub::Subscription

    registerSplitScreenChangedListener(::std::function<void(uchar)> callback) const /*override*/;


    virtual uchar getSplitScreenCount() const /*override*/;


    virtual float calculateScreenSizeToResolutionScalar(int const width, int const height) const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::GlobalResourcesCrashRecovery const> GetGlobalResourcesCrashRecovery() const

        /*override*/;


    virtual bool isReadyToRender() const /*override*/;


    virtual bool isShowingLoadingScreen() const /*override*/;


    virtual bool isRenderingLoadingScreen() const /*override*/;


    virtual void registerUpsellScreen() /*override*/;


    virtual ::SceneFactory& getPrimarySceneFactory() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ISceneStack const> getMainSceneStack() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ISceneStack> getMainSceneStack() /*override*/;


    virtual ::OreUI::Router& getUIRouter() /*override*/;


    virtual ::OreUI::DataProviderManager_DEPRECATED& getDataProviderManager() /*override*/;


    virtual ::std::weak_ptr<::RealmsAPI> getRealms() /*override*/;


    virtual ::Realms::ContentService& getRealmsContentService() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsServices> getRealmsServices() /*override*/;


    virtual ::std::weak_ptr<::ClubsService> getClubsService() /*override*/;


    virtual ::std::shared_ptr<::Realms::GenericRequestServiceHandler> getGenericRealmsService() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::SubscriptionService> getRealmsSubscriptionService() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::PresenceManager> getPresenceManager() /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::EDUSystems> getEDUSystems() /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::EDUSystems const> getEDUSystems() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Minecraft> getPrimaryMinecraft() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Automation::AutomationClient> getAutomationClient() const /*override*/;


    virtual bool isDedicatedServer() const /*override*/;


    virtual bool isEduMode() const /*override*/;


    virtual void onNetworkMaxPlayersChanged(uint newMaxPlayerCount) /*override*/;


    virtual ::IGameModuleApp& getGameModule() /*override*/;


    virtual ::IGameModuleShared& getGameModuleShared() /*override*/;


    virtual void requestServerShutdown() /*override*/;


    virtual void setLaunchedFromLegacyVersion(bool launchedFromLegacyVersion) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::FileArchiver> getFileArchiver() const /*override*/;


    virtual bool requestInGamePause(::SubClientId const& subClient, bool status) /*override*/;


    virtual ::InputMode getCurrentInputMode() const /*override*/;


    virtual void handleInputPaneHidden() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelLoader> getLevelLoader() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ExternalContentManager> getContentManager() /*override*/;


    virtual ::IContentManager& getResourceContentManager() /*override*/;


    virtual ::std::string getMultiplayerDisabledTextTitle(::MultiplayerLockedContext context) const /*override*/;


    virtual ::std::string getMultiplayerDisabledTextBody(::MultiplayerLockedContext context) const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IExternalServerFile> getExternalServer() const /*override*/;


    virtual ::std::shared_ptr<::mce::TextureGroup> getTextureGroup() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::mce::TextureGroup> getStoreCacheTextures() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::MinecraftGraphics> getMinecraftGraphics() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::TextureAtlas> getTextureAtlas() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IUIRepository> getUIRepository() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::SeasonsRenderer> getSeasonsRenderer() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::Core::FilePathManager> getFilePathManager() /*override*/;


    virtual void setUseFontOverrides(bool useOverrides) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getFontHandle() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getRuneFontHandle() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getUnicodeFontHandle() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getSmoothFontHandle() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getUIFontHandle() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::EmoticonManager const> getEmoticonManager() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper const> getTextToIconMapper() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper> getTextToIconMapper() /*override*/;


    virtual bool getMouseGrabbed() const /*override*/;


    virtual void navigateToPlayScreenFriendsTab() /*override*/;


    virtual bool hasActorResourceDefinitionGroup() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup const> getActorResourceDefinitionGroup() const

        /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup const> getRenderControllerGroup() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup> getRenderControllerGroup() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup>

    getActorResourceDefinitionGroupMutable() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::OreUI::IResourceAllowList> getOreUIResourceAllowList() /*override*/;


    virtual ::Bedrock::Threading::Async<::Core::PathBuffer<::std::string>>

    requestScreenshot(::ScreenshotOptions& screenshotOptions) /*override*/;


    virtual void onActiveResourcePacksChanged(::ResourcePackManager& mgr) /*override*/;


    virtual bool onFullPackStackInvalid() /*override*/;


    virtual void onLanguageSubpacksChanged() /*override*/;


    virtual void onBaseGamePackDownloadComplete() /*override*/;


    virtual void displayActiveDirectoryLoginDialog() /*override*/;


    virtual void handleReloadUIDefinitions() /*override*/;


    virtual void onPushNotificationReceived(::PushNotificationMessage const& msg) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::FlightingService> getFlightingService() const /*override*/;


    virtual ::std::shared_ptr<::FlightingService> getFlightingServicePtr() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::TreatmentPackDownloadMonitor const> getTreatmentPackDownloadMonitor() const

        /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IEntitlementManager> getEntitlementManager() /*override*/;


    virtual ::IDlcValidation& getDlcValidation() /*override*/;


    virtual ::ServicesManager& getServicesManager() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::SunsettingManager> getSunsettingManager() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::DateManager> getDateManager() const /*override*/;


    virtual void grabMouse() /*override*/;


    virtual void releaseMouse() /*override*/;


    virtual void muteAudio() /*override*/;


    virtual void unMuteAudio() /*override*/;


    virtual uint64 generateClientId(

        bool   generatedNewId,

        bool&  clientIdModifier,

        uint64 user,

        ::std::shared_ptr<::Social::User>

    ) /*override*/;


    virtual bool isHostingLocalDedicatedServer() const /*override*/;


    virtual void shutdownServer() /*override*/;


    virtual void pauseContentDownloads() /*override*/;


    virtual void resumeContentDownloads() /*override*/;


    virtual ::UIMeasureStrategy& getUIMeasureStrategy() /*override*/;


    virtual void copyInternalSettingsFolderToExternalLocation() const /*override*/;


    virtual void onClientLevelExit(::IClientInstance& exitClient, uint exitCode) /*override*/;


    virtual void resetThreadCallbacks() /*override*/;


    virtual bool isInGame() const /*override*/;


    virtual bool isInServer() const /*override*/;


    virtual bool isInRealm() const /*override*/;


    virtual void fadeOutMusic() /*override*/;


    virtual bool isInitialized() const /*override*/;


    virtual bool useMinecraftVersionOfXBLUI() const /*override*/;


    virtual int getMaxPlayerCount() const /*override*/;


    virtual void setProfilerIsOn(bool val) /*override*/;


    virtual void

    onPrimaryUserReconnect(::Social::UserPlatformConnectionResult status, bool isUserInitiated) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::CubemapBackgroundResources> getCubemapBackgroundResources() /*override*/;


    virtual void setAppWillTerminate(bool willTerminate) /*override*/;


    virtual ::DeferredTasksManager<::DeferredTaskCategory>& getDeferredTasks() /*override*/;


    virtual void onForceCloudSave() /*override*/;


    virtual void onOptionsLoadBegin() /*override*/;


    virtual void onOptionsLoadComplete() /*override*/;


    virtual bool shouldShowRatingsPrompt() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerInstanceEventCoordinator>

    getServerInstanceEventCoordinator() /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::IApp> getApp() /*override*/;


    virtual bool getSuspended() const /*override*/;


    virtual bool isResuming() const /*override*/;


    virtual void doPrimaryClientReadyWork(::std::function<void()> workFn) /*override*/;


    virtual void doUserManagerReadyWork(::std::function<void()> workFn) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ScreenshotRecorder> getScreenshotRecorder() /*override*/;


    virtual bool isEditorModeEnabled() const /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::ContentLogFileEndPoint> const getContentFileLogEndPoint() const /*override*/;


    virtual void tryShowXblFirstLaunchScreen(bool isUserConnectedToPlatform) /*override*/;


    virtual bool isMusicEnabled() const /*override*/;


    virtual void queueCustomMusic(

        ::std::string const& eventName,

        float                volume,

        float                fadeoutSeconds,

        ::MusicRepeatMode    playMode

    ) /*override*/;


    virtual void playCustomMusic(

        ::std::string const& eventName,

        float                volume,

        float                fadeoutSeconds,

        ::MusicRepeatMode    playMode

    ) /*override*/;


    virtual void setMusicCommandVolumeMultiplier(float volumeMultiplier) /*override*/;


    virtual void stopCustomMusic(float fadeoutSeconds) /*override*/;


    virtual ::EntityContext& getEntity() const /*override*/;


    virtual ::AppSystemRegistry& getAppSystemRegistry() /*override*/;


    virtual void onLanguageChanged(::std::string const& code, bool languageSystemInitializing) /*override*/;


    virtual void onLanguageKeywordsLoadedFromPack(::PackManifest const&) /*override*/;


    virtual void onLanguagesLoaded() /*override*/;


    virtual void buildTreatmentPackStack(bool fireEvents) const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelDbEnv> getLevelDbEnv() /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::ChunkSource>

    getClientGenChunkSource(::DimensionType const& dimensionType) /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::ProfanityContext> getProfanityContext() /*override*/;


    virtual double getGameUpdateDurationInSeconds() const /*override*/;


    virtual void queueSubclientRemoval(::SubClientId subid) /*override*/;


    virtual void logoffAllSubclients() /*override*/;


    virtual void setIsInGame(bool isInGame) /*override*/;


    virtual void createClientItemRegistry() /*override*/;


    virtual ::Bedrock::NonOwnerPointer<::MinecraftInputHandler> getInput() const /*override*/;


    virtual ::std::unique_ptr<::LocalServerLauncher::IGameInterface> createGameInterface() /*override*/;


    virtual ::std::unique_ptr<::LocalServerLauncher::IServerInstanceBuilder> createServerBuilder() /*override*/;


    virtual ::std::unique_ptr<::LocalServerLauncher::GameDependencies> createGameDependencies() /*override*/;


    virtual ::TaskGroup& _getServerInitTaskGroup() /*override*/;


    virtual bool

    checkMultiPlayerPermission(::std::optional<::Social::MultiplayerServiceIdentifier> service) /*override*/;


    virtual bool isPlayingLevel() const /*override*/;


    virtual void initImpl() /*override*/;


    virtual void refocusMouse(bool lostMouse) /*override*/;


    virtual void setMouseType(::Bedrock::Input::PointerType type) /*override*/;


    virtual void onNotify(::edu::auth::CredentialsAcquired const& state) /*override*/;


    virtual void onNotify(::edu::auth::CredentialsRefreshSuccess const& state) /*override*/;


    virtual void onNotify(::edu::auth::GenericCredentialsEvent<::edu::auth::CredsLost> const& state) /*override*/;


    virtual bool checkForPiracy() const /*override*/;


    virtual ::Bedrock::NotNullNonOwnerPtr<::DevConsoleLogger> getDevConsoleLogger() const /*override*/;


    virtual void completeServerStartup(

        ::std::shared_ptr<::LocalServerLauncher::ServerInitData> serverInitData,

        ::LocalServerLauncher::ServerLaunchResult&&              result

    ) /*override*/;

    // NOLINTEND


public:

    // member functions

    // NOLINTBEGIN

    MCAPI explicit MinecraftGame(::MinecraftGameArguments&& args);


    MCAPI void _InitComplete();


    MCAPI void _LoadRendererAssets();


    MCAPI void _addSubClientInstanceAndAssociateToUserInternal(int controllerId, bool isInitialCheck);


    MCAPI void _beginReloadingResources();


    MCAPI void _buildClientStack();


    MCAPI void _buildClientStartupStack();


    MCAPI bool _clientUpdate();


    MCAPI void _configureLighting();


    MCAPI ::LocalServerLauncher::Impl::AllDependencies _createAllDependencies();


    MCAPI ::std::shared_ptr<::ClientInstance>

    _createClientInstance(::SubClientId id, ::LatencyGraphDisplay* latencyDisplay, int controller);


    MCAPI ::brstd::move_only_function<::std::unique_ptr<::IClientDimensionExtensions>(bool) const>

    _createDimensionExtensionsFactory(bool isClientSide);


    MCAPI ::std::unique_ptr<::GameModuleClient> _createGameModuleClient(::SubClientId id);


    MCAPI void _createPartySystem();


    MCAPI void _cycleRoundRobinClientSubId();


    MCAPI void _deinitOptionObservers(::IClientInstance& client);


    MCAPI ::std::unique_ptr<::ResourcePackStack> _deserializeGlobalResourcePacks();


    MCAPI void _deviceReinitialization(

        ::SerialWorkList&                                         workList,

        ::std::optional<::dragon::framerenderer::DebugParameters> initDebugOptions

    );


    MCAPI void _finishReloadingResources(::ResourcePackManager& mgr, bool fullVanillaPackOnStack);


    MCAPI ::Bedrock::Threading::Async<void> _handleMultiplayerServiceJoinResult(

        ::Social::MultiplayerServiceIdentifier gameServiceProvider,

        ::Social::JoinGameStatus               succeeded,

        ::Social::MultiplayerGameInfo const&   newGame,

        bool                                   isLan

    );


    MCAPI void _initAppConfigs();


    MCAPI ::SerialWorkList::WorkResult _initAudio();


    MCAPI ::SerialWorkList::WorkResult _initCheckStorage();


    MCAPI ::SerialWorkList::WorkResult _initClientNetworkSystem();


    MCAPI ::SerialWorkList::WorkResult _initCrashReporting();


    MCAPI ::SerialWorkList::WorkResult

    _initCreatePrimaryClient(::std::shared_ptr<::MinecraftGame::InitContext> initContext);


    MCAPI ::SerialWorkList::WorkResult _initDatabase();


    MCAPI ::SerialWorkList::WorkResult _initDefaultFonts();


    MCAPI ::SerialWorkList::WorkResult _initDeviceDebugConfig();


    MCAPI void _initEcoModeSystem();


    MCAPI void _initEntityContext();


    MCAPI ::SerialWorkList::WorkResult _initEventing();


    MCAPI ::SerialWorkList::WorkResult _initFileSystemSpaceTracking();


    MCAPI ::SerialWorkList::WorkResult _initFinish(::std::shared_ptr<::MinecraftGame::InitContext>& initContext);


    MCAPI ::SerialWorkList::WorkResult _initFontHandles();


    MCAPI ::SerialWorkList::WorkResult _initFontMetadata();


    MCAPI ::SerialWorkList::WorkResult _initHideSplashScreen();


    MCAPI ::SerialWorkList::WorkResult _initHttp();


    MCAPI ::SerialWorkList::WorkResult _initIssueHardwareCursorLoad();


    MCAPI ::SerialWorkList::WorkResult _initLoadRendererAssets();


    MCAPI ::SerialWorkList::WorkResult _initLoadingBarMaterials();


    MCAPI ::SerialWorkList::WorkResult _initLogging();


    MCAPI void _initMinecraftGame();


    MCAPI ::SerialWorkList::WorkResult _initMultiplayerMgr();


    MCAPI ::SerialWorkList::WorkResult _initMultiplayerRequestHandler();


    MCAPI ::SerialWorkList::WorkResult _initNetworkSessionOwner();


    MCAPI ::SerialWorkList::WorkResult _initNewPlayerSystem();


    MCAPI ::SerialWorkList::WorkResult _initNotifyOnActiveResourcePacksChanged();


    MCAPI ::SerialWorkList::WorkResult _initOnGameSessionReset();


    MCAPI ::SerialWorkList::WorkResult _initOreUIAssets();


    MCAPI ::SerialWorkList::WorkResult _initOreUIDataProviderManager();


    MCAPI ::SerialWorkList::WorkResult _initOreUIRendering();


    MCAPI ::SerialWorkList::WorkResult _initOreUISystem(::std::shared_ptr<::MinecraftGame::InitContext> initContext);


    MCAPI ::SerialWorkList::WorkResult _initOreUIViewsCoordinator();


    MCAPI ::SerialWorkList::WorkResult _initPacks();


    MCAPI ::SerialWorkList::WorkResult _initPartySystem();


    MCAPI void _initPerMachineOptionObservers();


    MCAPI void _initPerUserOptionObservers(::Bedrock::NotNullNonOwnerPtr<::IClientInstance> const& client);


    MCAPI ::SerialWorkList::WorkResult _initPostA();


    MCAPI ::SerialWorkList::WorkResult _initPostB();


    MCAPI ::SerialWorkList::WorkResult _initPostC();


    MCAPI ::SerialWorkList::WorkResult _initPostE();


    MCAPI ::SerialWorkList::WorkResult _initPostFontAsync();


    MCAPI ::SerialWorkList::WorkResult _initPreCacheOutOfGameViews();


    MCAPI ::SerialWorkList::WorkResult

    _initPrimaryClientComplete(::std::shared_ptr<::MinecraftGame::InitContext> initContext);


    MCAPI ::SerialWorkList::WorkResult _initPrimaryIdentity();


    MCAPI ::SerialWorkList::WorkResult _initProgressTips();


    MCAPI ::SerialWorkList::WorkResult _initPushAlwaysActiveScreen();


    MCAPI ::SerialWorkList::WorkResult _initRealmsSystem();


    MCAPI ::SerialWorkList::WorkResult _initRepopulateLevelInfoCache();


    MCAPI ::SerialWorkList::WorkResult _initResourceLoader();


    MCAPI void _initServicesManager();


    MCAPI ::SerialWorkList::WorkResult _initSocialSystem();


    MCAPI ::SerialWorkList::WorkResult _initStep1();


    MCAPI ::SerialWorkList::WorkResult _initStep2();


    MCAPI ::SerialWorkList::WorkResult _initStep2A();


    MCAPI ::SerialWorkList::WorkResult _initStep2B();


    MCAPI ::SerialWorkList::WorkResult _initStep3();


    MCAPI ::SerialWorkList::WorkResult _initStep5();


    MCFOLD ::SerialWorkList::WorkResult _initStorageMigration();


    MCAPI ::SerialWorkList::WorkResult _initTTS();


    MCAPI ::SerialWorkList::WorkResult _initTestClientInterface();


    MCAPI ::SerialWorkList::WorkResult _initTimePlayedNotifier();


    MCAPI ::SerialWorkList::WorkResult _initTriggerSignIn();


    MCAPI ::SerialWorkList::WorkResult _initUILoadAsyncWait();


    MCAPI ::SerialWorkList::WorkResult _initUpdateAppLaunchedCount();


    MCAPI ::SerialWorkList::WorkResult _initUpdateFontsBasedOffOfOverrideEnable();


    MCAPI ::SerialWorkList::WorkResult _initUser();


    MCAPI ::SerialWorkList::WorkResult _initUserComplete();


    MCAPI ::SerialWorkList::WorkResult _initWaitForContentManager();


    MCAPI ::SerialWorkList::WorkResult _initWaitForDefaultFontsToLoad();


    MCAPI ::SerialWorkList::WorkResult _initWaitForDiscoveryService();


    MCAPI ::SerialWorkList::WorkResult _initWaitForEntitlementCacheLoad();


    MCAPI ::SerialWorkList::WorkResult _initWaitForFontMetadataToLoad();


    MCAPI ::SerialWorkList::WorkResult _initWaitForFrameBuilder();


    MCAPI ::SerialWorkList::WorkResult _initWaitForInitialServicePacks();


    MCAPI ::SerialWorkList::WorkResult _initWaitForLocalization();


    MCAPI ::SerialWorkList::WorkResult _initWaitForMainMenuResources();


    MCAPI ::SerialWorkList::WorkResult _initWaitForOfferLicense();


    MCAPI ::SerialWorkList::WorkResult _initWaitForOfferRepo();


    MCAPI ::SerialWorkList::WorkResult _initWaitForOreUIAssets() const;


    MCAPI ::SerialWorkList::WorkResult _initWaitForPrimaryUser();


    MCAPI ::SerialWorkList::WorkResult _initWaitForRepopulateLevelInfoCache();


    MCAPI ::SerialWorkList::WorkResult _initWaitForResourceRepository();


    MCAPI ::SerialWorkList::WorkResult _initWaitForSkinRepo();


    MCAPI ::SerialWorkList::WorkResult _initWaitForWorldTemplateManager();


    MCAPI ::SerialWorkList::WorkResult _initWorldSystem();


    MCAPI ::SerialWorkList::WorkResult _initializeFrameBuilder();


    MCAPI void _initializeTextureStreamingResources();


    MCAPI bool _isFriendsDrawerEnabledIngame() const;


    MCAPI bool _isGameplayPaused();


    MCAPI bool _isWaitingOnADAuthentication() const;


    MCAPI ::Bedrock::Threading::Async<void> _joinMultiplayerGame(

        ::Social::MultiplayerGameInfo const& gameToJoin,

        ::std::string const&                 multiplayerCorrelationId,

        ::PlayerJoinWorldContext             context

    );


    MCAPI void _joinRealmFromMultiplayerServiceInvite(::Social::MultiplayerGameInfo const& newGame);


    MCAPI void _loadAdditionalPackResources(bool fullVanillaPackOnStack);


    MCAPI ::SerialWorkList::WorkResult _loadGlobalResourcePacks();


    MCAPI void _loadInitialPackResources(::ResourcePackManager& mgr, bool fullVanillaPackOnStack);


    MCAPI void _loadLanguageData();


    MCAPI void _loadLastGlobalResourcePacksFromFile(bool waitForUIReload);


    MCAPI void _loadSoundAndMusic();


    MCAPI ::SerialWorkList::WorkResult _notifyOnFullVanillaPackOnStack();


    MCAPI void _onActiveResourcePacksChanged(::ResourcePackManager& mgr, bool fullVanillaPackOnStack);


    MCAPI void _onDeviceLostRecovery();


    MCAPI ::SerialWorkList::WorkResult _onDeviceRestoreFinish();


    MCAPI void _onEntitlementsChanged();


    MCAPI void _onEntitlementsChangedNotifyUI();


    MCAPI void _onInitRemoteSystem(::std::function<void()> syncCompleteCallback);


    MCAPI void _onPrimaryUserConnectComplete(

        ::Social::UserPlatformConnectionResult status,

        bool                                   runStartScreen,

        bool                                   userInitiated

    );


    MCAPI ::SerialWorkList::WorkResult _onResumeBegin();


    MCAPI ::SerialWorkList::WorkResult _onResumeFinish();


    MCAPI ::SerialWorkList::WorkResult _onResumeHttp();


    MCAPI ::SerialWorkList::WorkResult _onResumePrimaryClient();


    MCAPI ::SerialWorkList::WorkResult _onResumeQueueFontReloadTextures();


    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadActors();


    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadAnimation();


    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadParticleEffects();


    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadTextures();


    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadTexturesAtlas();


    MCAPI ::SerialWorkList::WorkResult _onResumeReloadDefaultLighting();


    MCAPI ::SerialWorkList::WorkResult _onResumeRestartServices();


    MCAPI ::SerialWorkList::WorkResult _onResumeWaitFontReloadTextures();


    MCAPI ::SerialWorkList::WorkResult _onResumeWaitPreviousResourceLoads();


    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadActors();


    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadAnimation();


    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadParticleEffects();


    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadTextures();


    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadTexturesAtlas();


    MCAPI void _onSplitScreenChanged();


    MCAPI void _onStorageDirectoryChanged(::Core::Path const& path);


    MCAPI void _onTTSOptionChanged();


    MCAPI void _onTTSOptionChanged(bool enabled);


    MCAPI void _onTextureAtlasStatus(::TextureAtlasStatus const&);


    MCAPI void _onUserSigninPlayFab(uint userId);


    MCAPI void _onUserSigninXboxLive(uint userId);


    MCAPI void _onUserSignoutPlayFab(uint userId);


    MCAPI void _onUserSignoutXboxLive(uint userId);


    MCAPI void _performNetworkReadyActions();


    MCAPI bool _platformShowsHdrCalibrationScreen();


    MCAPI void _preCacheOutOfGameViews();


    MCAPI void _recomputeResolution();


    MCAPI void _registerClientOptionLock(

        ::SubClientId                clientId,

        ::Option*                    option,

        ::std::function<void(bool&)> isModifiableCondition

    );


    MCAPI void _registerClientOptionObserver(

        ::SubClientId                          clientId,

        ::Option*                              option,

        ::std::function<void(::Option const&)> onValueChangeCallback

    );


    MCAPI ::Bedrock::ScopeExit _registerOnInitUriListeners();


    MCAPI void _registerPrimaryUserOptionLock(::Option* option, ::std::function<void(bool&)> isModifiableCondition);


    MCAPI void

    _registerPrimaryUserOptionObserver(::Option* option, ::std::function<void(::Option const&)> onValueChangeCallback);


    MCAPI void _reloadLightingTextures();


    MCAPI void _removePendingSubclients();


    MCAPI void _setupFrameBuilderOptimizer();


    MCAPI void _setupRenderer();


    MCAPI void _teardownRenderer(bool removeDevice);


    MCAPI void _terminateRenderer();


    MCAPI void _unregisterOnInitUriListeners();


    MCAPI void _update();


    MCAPI void _updateLightingModel();


    MCAPI void _updatePackStackForLeaveGame();


    MCAPI void _updatePerformanceTrackers();


    MCAPI void _updateProfilerLite();


    MCAPI void _updateTextureAtlasPBRData(::TextureAtlas const& textureAtlas, bool terrain);


    MCAPI ::SerialWorkList::WorkResult _waitForAudio();


    MCAPI ::SerialWorkList::WorkResult _waitForFileSystemSpaceTracking();


    MCAPI ::SerialWorkList::WorkResult _waitForLoadRendererAssets();


    MCAPI ::SerialWorkList::WorkResult _waitForStorageMigration();


    MCAPI void adjustClientsUISizeAndScale();


    MCAPI void cleanReloadMaterials();


    MCAPI uint continueLeaveGame();


    MCAPI bool currentScreenShouldStealMouse();


    MCAPI void doInitializationCompleteWork(::std::function<void()> workFn);


    MCAPI void endFrame();


    MCAPI ::std::shared_ptr<::ClientBlobCache::Cache> getClientBlobCache();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IClientInstance> getClientInstance(::SubClientId subid);


    MCAPI ::Bedrock::NonOwnerPointer<::ServerNetworkHandler> getServerNetworkHandler();


    MCAPI void handleLicenseChanged();


    MCAPI void handleShowUpsellScreen(bool timeExpired);


    MCAPI void initEventing();


    MCAPI bool isInEDUMultiplayerSession();


    MCAPI bool isServerVisible();


    MCAPI void onTick();


    MCAPI bool primaryLevelExists() const;


    MCAPI void reloadMaterials();


    MCAPI void setDpadScale();


    MCAPI void startFrame();


    MCAPI void tickInput();


    MCAPI bool tryGetIdForNewSubClient(int controllerId, ::SubClientId& outNewClientId, bool isInitialCheck) const;


    MCAPI void updateAudio(::Bedrock::NotNullNonOwnerPtr<::IClientInstance> const& client, ::Timer const& timer);


    MCAPI void updateGraphics(::Bedrock::NotNullNonOwnerPtr<::IClientInstance> const& client, ::Timer const& timer);

    // NOLINTEND


public:

    // constructor thunks

    // NOLINTBEGIN

    MCAPI void* $ctor(::MinecraftGameArguments&& args);

    // NOLINTEND


public:

    // destructor thunk

    // NOLINTBEGIN

    MCAPI void $dtor();

    // NOLINTEND


public:

    // virtual function thunks

    // NOLINTBEGIN

    MCAPI void $initialize();


    MCAPI bool $stop();


    MCAPI void $processActivationArguments(::Bedrock::ActivationArguments const& args);


    MCAPI void $audioEngineOn();


    MCAPI void $audioEngineOff();


    MCAPI void $update();


    MCAPI void $play(::std::string const& name, ::Vec3 const& pos, float volume, float pitch);


    MCAPI void $playUI(::std::string const& name, float volume, float pitch);


    MCAPI void $stopSound(::std::string const& name);


    MCAPI void $stopSounds();


    MCAPI void $setUISizeAndScale(int w, int h, float forcedGuiScale);


    MCAPI void $setRenderingSize(int w, int h);


    MCAPI void $recalculateScene();


    MCAPI void $setSmoothFontStyle();


    MCAPI void $setUIFontStyle();


    MCAPI ::Bedrock::Threading::Async<void> $startLocalServerAsync(

        ::std::string const&     levelId,

        ::std::string const&     levelName,

        ::ContentIdentity const& premiumTemplateContentIdentity,

        ::LevelSettings const&   settings,

        ::StartIntent            startIntent

    );


    MCAPI void $createAndUploadWorldToRealm(

        ::std::string const&                   levelId,

        ::std::string const&                   levelName,

        ::ContentIdentity const&               premiumTemplateContentIdentity,

        ::LevelSettings const&                 settings,

        ::Realms::World                        world,

        ::std::function<void(::Realms::World)> callback

    );


    MCAPI bool $canStartLocalServer() const;


    MCAPI bool $isAudioInitialized() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::SoundEngine> $getSoundEngine() const;


    MCFOLD ::MusicManager const* $getMusicManager() const;


    MCFOLD ::MusicManager* $getMusicManagerNonConst() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ITextBoxController> $getTextBoxController();


    MCAPI void $onLowMemory(::LowMemorySeverity);


    MCAPI void $onAppFocusLost();


    MCAPI void $onAppFocusGained();


    MCAPI void $onAppPaused();


    MCAPI void $onAppUnpaused();


    MCAPI void $setReconnectionCookie(

        ::std::optional<::std::variant<

            ::GameConnectionInfoEx,

            ::Social::MultiplayerGameInfo,

            ::ExperienceConnectionData,

            ::Realms::RealmId>> const& reconnectCookie

    );


    MCAPI ::std::optional<::std::variant<

        ::GameConnectionInfoEx,

        ::Social::MultiplayerGameInfo,

        ::ExperienceConnectionData,

        ::Realms::RealmId>>

    $getReconnectionCookie();


    MCAPI void $onAppPreSuspended();


    MCAPI void $onAppSuspended();


    MCAPI void $onAppResumed();


    MCAPI void $onDeviceLost();


    MCAPI void $onAppSurfaceCreated();


    MCAPI void $onAppSurfaceDestroyed();


    MCAPI void $openPauseMenu();


    MCAPI bool $hasNetworkPrivileges(bool onlyWifiAllowed);


    MCAPI void $onPlayerLoaded(::IClientInstance& client, ::Player& player);


    MCAPI void $onDimensionChanged();


    MCAPI void $setDisableInputForAllOtherClients(int id, bool disableStatus);


    MCAPI void $onGameEventNotification(::ui::GameEventNotification notification);


    MCAPI void $playerListChanged();


    MCAPI void $onLevelDestruction(::std::string const& levelId);


    MCAPI void $setWorldTransferAction(

        ::std::variant<

            ::LocalWorldTransferActionFunc,

            ::ExternalWorldTransferActionFunc,

            ::RealmTransferActionFunc,

            ::std::monostate>&& worldTransferAction

    );


    MCAPI ::std::variant<

        ::LocalWorldTransferActionFunc,

        ::ExternalWorldTransferActionFunc,

        ::RealmTransferActionFunc,

        ::std::monostate> const&

    $getWorldTransferAction() const;


    MCAPI ::Bedrock::NonOwnerPointer<::WorldTransferAgent> const $getWorldTransferAgent() const;


    MCAPI void $setIsWorldTransferInProgress(bool isWorldTransferInProgress);


    MCAPI bool $isWorldTransferInProgress() const;


    MCFOLD void $setResetCallbackObject(::ResetCallbackObject* obj);


    MCAPI void $requestLeaveGame(bool switchScreen, bool sync);


    MCAPI void $requestLeaveThenJoinFriendsWorld(::std::string_view serverId);


    MCAPI void $startLeaveGame();


    MCAPI bool $isLeaveGameDone() const;


    MCAPI void $destroyGame();


    MCAPI void $setupCommandParser(::IClientInstance& client);


    MCAPI void $onClientCreatedLevel(::IClientInstance& client);


    MCAPI ::GameRenderer& $getGameRenderer() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IUIDefRepository> $getUIDefRepo() const;


    MCAPI void $joinRealmsGame(

        ::Realms::World const&              realm,

        ::Social::GameConnectionInfo const& gameConnection,

        ::PlayerJoinWorldContext            context

    );


    MCAPI void $joinRealmFromInvite(::Realms::World const& world);


    MCAPI void $joinRealmFromConnectLink(::Realms::World const& world, ::PlayerJoinWorldContext context);


    MCAPI void $setRealmsLoadingLink(bool state);


    MCAPI void $joinRealm(

        ::Realms::World const&                    world,

        ::IMinecraftEventing::RealmConnectionFlow telemetryEventingConnectionFlow,

        ::PlayerJoinWorldContext                  context

    );


    MCAPI ::Bedrock::Threading::Async<void>

    $joinMultiplayerGame(::Social::MultiplayerGameInfo const& gameInfo, ::PlayerJoinWorldContext context);


    MCAPI void $joinMultiplayerWithAddress(

        ::Social::GameConnectionInfo gameConnection,

        bool                         joiningLocalServer,

        ::std::string const&         serverName,

        ::std::string const&         worldName,

        ::NetworkType                networkTypeOverride,

        ::PlayerJoinWorldContext     context

    );


    MCAPI void $joinRemoteServerWithAddress(

        ::Social::GameConnectionInfo gameConnection,

        ::std::string const&         serverName,

        ::std::string const&         worldName,

        ::NetworkType                networkTypeOverride,

        ::PlayerJoinWorldContext     context

    );


    MCAPI bool $isLocalPlayer(::ActorUniqueID const& id) const;


    MCAPI void $setLeaveGameInProgressAsReadyToContinue();


    MCAPI bool $isPrimaryClientInstanceReady() const;


    MCAPI void $ensureAllClientsAreLeaving() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IClientInstance> $getPrimaryClientInstance();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IClientInstance const> $getPrimaryClientInstance() const;


    MCAPI ::ItemRegistryRef $getClientItemRegistry() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem> $getNewPlayerSystem();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem const> $getNewPlayerSystem() const;


    MCFOLD ::std::map<::SubClientId, ::std::shared_ptr<::IClientInstance>> const& $getClientInstanceMap() const;


    MCAPI ::std::shared_ptr<::IClientInstance> $tryGetClientInstanceFromPlayerUUID(::mce::UUID const& playerId) const;


    MCAPI uint $getUIRenderClientMask() const;


    MCAPI uint64 $getClientInstanceCount() const;


    MCAPI void $forEachClientInstance(::std::function<void(::IClientInstance&)> callback);


    MCAPI ::LocalPlayer* $getPrimaryLocalPlayer();


    MCAPI ::LocalPlayer const* $getPrimaryLocalPlayer() const;


    MCAPI bool $isPrimaryLevelCrossPlatformMultiplayer() const;


    MCAPI bool $isPrimaryLevelMultiplayer() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GuiData> $getPrimaryGuiData();


    MCAPI ::std::shared_ptr<::OptionRegistry> $getPrimaryUserOptions();


    MCAPI ::std::shared_ptr<::OptionRegistry const> $getPrimaryUserOptions() const;


    MCAPI bool $isPrimaryUserSigninInProgress() const;


    MCAPI void $resetInput();


    MCFOLD ::PixelCalc const& $getDpadScale() const;


    MCAPI void $setKeyboardForcedHeight(float height, bool isShowSignal);


    MCAPI bool $canActivateKeyboard();


    MCAPI void $reloadAnimationAndGeometryData(bool sync);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GeometryGroup> $getGeometryGroup() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::BlockCullingGroup> $getBlockCullingGroup() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ClientBlockPipeline::SchematicsRepository> $getSchematicsRepository() const;


    MCFOLD ::ParticleEffectGroup& $getParticleEffectGroup() const;


    MCAPI ::DeferredLighting& $getDeferredLighting() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ContentAcquisition> $getContentAcquisition() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IOfferRepository> $getOfferRepository() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TrialManager> $getTrialManager() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::PersonaService> $getPersonaService() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GatheringManager> $getGatheringManager() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ContentCatalogService> $getContentCatalogService() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::StoreCatalogRepository> $getStoreCatalog() const;


    MCAPI ::ServiceDrivenImageRepository& $getServiceImageRepository() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LibraryRepository> $getLibraryRepository() const;


    MCAPI ::std::shared_ptr<::ActorAnimationGroup> $getActorAnimationGroup() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationControllerGroup> $getActorAnimationControllerGroup() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository const> $getThirdPartyServerRepository() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository> $getThirdPartyServerRepository();


    MCAPI ::std::shared_ptr<::SkinRepository> $getSkinRepository() const;


    MCAPI ::PersonaRepository& $getPersonaRepository() const;


    MCAPI ::MarketplaceServicesManager& $getMarketplaceServicesManager() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::WorldTemplateManager> $getWorldTemplateManager() const;


    MCAPI ::World::WorldSystem& $getWorldSystem() const;


    MCAPI bool $isWorldSystemReady() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsSystem> $getRealmsSystem() const;


    MCAPI ::Social::SocialSystem& $getSocialSystem() const;


    MCAPI ::Bedrock::NonOwnerPointer<::Parties::PartySystem> $getPartySystem() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Progress::ProgressTips> $getUIProgressTips() const;


    MCAPI ::IResourcePackRepository& $getResourcePackRepository() const;


    MCFOLD ::ResourcePackManager& $getResourcePackManager() const;


    MCAPI ::ResourcePackManager& $getServerResourcePackManager();


    MCFOLD ::PackManifestFactory& $getPackManifestFactory();


    MCAPI ::PlayerMessagingService& $getPlayerMessagingService();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::IContentKeyProvider const> $getKeyProvider() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider const> $getAccessibilityProvider() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider> $getAccessibilityProvider();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IContentTierManager const> $getContentTierManager() const;


    MCAPI ::PackSourceFactory& $getPackSourceFactory() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ResourceLoadManager> $getResourceLoadManager();


    MCAPI ::ILevelListCache& $getLevelListCache();


    MCAPI bool $hasAllValidCrossPlatformSkin() const;


    MCAPI ::PackDownloadManager& $getPackDownloadManager();


    MCFOLD ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> $getLinkedAssetValidator() const;


    MCFOLD bool $isMultiplayerServiceManagerReady() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Social::MultiplayerServiceManager> $getMultiplayerServiceManager() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Social::IUserManager> $getUserManager() const;


    MCAPI ::IMinecraftEventing& $getEventing() const;


    MCAPI ::ServerInstance* $getServerInstance();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ServerInstance> $getServerInstanceNonOwnPtr();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ClientNetworkSystem> $getClientNetworkSystemPtr();


    MCAPI ::ClientNetworkSystem& $getClientNetworkSystem();


    MCAPI ::ClientNetworkSystem const& $getClientNetworkSystem() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActiveDirectoryIdentity> $getActiveDirectoryIdentity();


    MCAPI void $clearCache();


    MCAPI void $releaseClientSubId(::SubClientId subid);


    MCAPI bool $isStartingGame() const;


    MCAPI bool $isSplitscreenJoinEnabled() const;


    MCAPI bool $canAddSplitscreenSubClient(int controllerId) const;


    MCAPI void $addSubClientInstanceAndAssociateToUser(int controllerId);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ControllerIDtoClientMap> $retrieveCIDToClientMap();


    MCAPI ::Bedrock::PubSub::Subscription

    $registerSplitScreenChangedListener(::std::function<void(uchar)> callback) const;


    MCAPI uchar $getSplitScreenCount() const;


    MCAPI float $calculateScreenSizeToResolutionScalar(int const width, int const height) const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GlobalResourcesCrashRecovery const> $GetGlobalResourcesCrashRecovery() const;


    MCAPI bool $isReadyToRender() const;


    MCAPI bool $isShowingLoadingScreen() const;


    MCAPI bool $isRenderingLoadingScreen() const;


    MCAPI void $registerUpsellScreen();


    MCAPI ::SceneFactory& $getPrimarySceneFactory() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ISceneStack const> $getMainSceneStack() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ISceneStack> $getMainSceneStack();


    MCAPI ::OreUI::Router& $getUIRouter();


    MCAPI ::OreUI::DataProviderManager_DEPRECATED& $getDataProviderManager();


    MCAPI ::std::weak_ptr<::RealmsAPI> $getRealms();


    MCAPI ::Realms::ContentService& $getRealmsContentService();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsServices> $getRealmsServices();


    MCAPI ::std::weak_ptr<::ClubsService> $getClubsService();


    MCAPI ::std::shared_ptr<::Realms::GenericRequestServiceHandler> $getGenericRealmsService();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Realms::SubscriptionService> $getRealmsSubscriptionService();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Social::PresenceManager> $getPresenceManager();


    MCFOLD ::Bedrock::NonOwnerPointer<::EDUSystems> $getEDUSystems();


    MCFOLD ::Bedrock::NonOwnerPointer<::EDUSystems const> $getEDUSystems() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Minecraft> $getPrimaryMinecraft();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Automation::AutomationClient> $getAutomationClient() const;


    MCFOLD bool $isDedicatedServer() const;


    MCFOLD bool $isEduMode() const;


    MCAPI void $onNetworkMaxPlayersChanged(uint newMaxPlayerCount);


    MCFOLD ::IGameModuleApp& $getGameModule();


    MCFOLD ::IGameModuleShared& $getGameModuleShared();


    MCAPI void $requestServerShutdown();


    MCAPI void $setLaunchedFromLegacyVersion(bool launchedFromLegacyVersion);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FileArchiver> $getFileArchiver() const;


    MCAPI bool $requestInGamePause(::SubClientId const& subClient, bool status);


    MCAPI ::InputMode $getCurrentInputMode() const;


    MCAPI void $handleInputPaneHidden();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelLoader> $getLevelLoader();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ExternalContentManager> $getContentManager();


    MCAPI ::IContentManager& $getResourceContentManager();


    MCAPI ::std::string $getMultiplayerDisabledTextTitle(::MultiplayerLockedContext context) const;


    MCAPI ::std::string $getMultiplayerDisabledTextBody(::MultiplayerLockedContext context) const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::IExternalServerFile> $getExternalServer() const;


    MCAPI ::std::shared_ptr<::mce::TextureGroup> $getTextureGroup() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::mce::TextureGroup> $getStoreCacheTextures() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::MinecraftGraphics> $getMinecraftGraphics();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TextureAtlas> $getTextureAtlas();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IUIRepository> $getUIRepository() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::SeasonsRenderer> $getSeasonsRenderer();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Core::FilePathManager> $getFilePathManager();


    MCAPI void $setUseFontOverrides(bool useOverrides);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> $getFontHandle() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> $getRuneFontHandle() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> $getUnicodeFontHandle() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> $getSmoothFontHandle() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> $getUIFontHandle() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::EmoticonManager const> $getEmoticonManager() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper const> $getTextToIconMapper() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper> $getTextToIconMapper();


    MCFOLD bool $getMouseGrabbed() const;


    MCAPI void $navigateToPlayScreenFriendsTab();


    MCAPI bool $hasActorResourceDefinitionGroup() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup const> $getActorResourceDefinitionGroup() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup const> $getRenderControllerGroup() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup> $getRenderControllerGroup();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup> $getActorResourceDefinitionGroupMutable();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::OreUI::IResourceAllowList> $getOreUIResourceAllowList();


    MCAPI ::Bedrock::Threading::Async<::Core::PathBuffer<::std::string>>

    $requestScreenshot(::ScreenshotOptions& screenshotOptions);


    MCAPI void $onActiveResourcePacksChanged(::ResourcePackManager& mgr);


    MCAPI bool $onFullPackStackInvalid();


    MCAPI void $onLanguageSubpacksChanged();


    MCAPI void $onBaseGamePackDownloadComplete();


    MCAPI void $displayActiveDirectoryLoginDialog();


    MCAPI void $handleReloadUIDefinitions();


    MCAPI void $onPushNotificationReceived(::PushNotificationMessage const& msg);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FlightingService> $getFlightingService() const;


    MCAPI ::std::shared_ptr<::FlightingService> $getFlightingServicePtr() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TreatmentPackDownloadMonitor const> $getTreatmentPackDownloadMonitor() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IEntitlementManager> $getEntitlementManager();


    MCFOLD ::IDlcValidation& $getDlcValidation();


    MCAPI ::ServicesManager& $getServicesManager();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::SunsettingManager> $getSunsettingManager();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::DateManager> $getDateManager() const;


    MCAPI void $grabMouse();


    MCAPI void $releaseMouse();


    MCAPI void $muteAudio();


    MCAPI void $unMuteAudio();


    MCAPI uint64

    $generateClientId(bool generatedNewId, bool& clientIdModifier, uint64 user, ::std::shared_ptr<::Social::User>);


    MCFOLD bool $isHostingLocalDedicatedServer() const;


    MCAPI void $shutdownServer();


    MCAPI void $pauseContentDownloads();


    MCAPI void $resumeContentDownloads();


    MCFOLD ::UIMeasureStrategy& $getUIMeasureStrategy();


    MCFOLD void $copyInternalSettingsFolderToExternalLocation() const;


    MCAPI void $onClientLevelExit(::IClientInstance& exitClient, uint exitCode);


    MCAPI void $resetThreadCallbacks();


    MCAPI bool $isInGame() const;


    MCAPI bool $isInServer() const;


    MCAPI bool $isInRealm() const;


    MCAPI void $fadeOutMusic();


    MCAPI bool $isInitialized() const;


    MCFOLD bool $useMinecraftVersionOfXBLUI() const;


    MCAPI int $getMaxPlayerCount() const;


    MCAPI void $setProfilerIsOn(bool val);


    MCAPI void $onPrimaryUserReconnect(::Social::UserPlatformConnectionResult status, bool isUserInitiated);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::CubemapBackgroundResources> $getCubemapBackgroundResources();


    MCAPI void $setAppWillTerminate(bool willTerminate);


    MCAPI ::DeferredTasksManager<::DeferredTaskCategory>& $getDeferredTasks();


    MCFOLD void $onForceCloudSave();


    MCAPI void $onOptionsLoadBegin();


    MCAPI void $onOptionsLoadComplete();


    MCAPI bool $shouldShowRatingsPrompt() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ServerInstanceEventCoordinator> $getServerInstanceEventCoordinator();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IApp> $getApp();


    MCAPI bool $getSuspended() const;


    MCAPI bool $isResuming() const;


    MCAPI void $doPrimaryClientReadyWork(::std::function<void()> workFn);


    MCAPI void $doUserManagerReadyWork(::std::function<void()> workFn);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ScreenshotRecorder> $getScreenshotRecorder();


    MCAPI bool $isEditorModeEnabled() const;


    MCAPI ::Bedrock::NonOwnerPointer<::ContentLogFileEndPoint> const $getContentFileLogEndPoint() const;


    MCAPI void $tryShowXblFirstLaunchScreen(bool isUserConnectedToPlatform);


    MCAPI bool $isMusicEnabled() const;


    MCAPI void

    $queueCustomMusic(::std::string const& eventName, float volume, float fadeoutSeconds, ::MusicRepeatMode playMode);


    MCAPI void

    $playCustomMusic(::std::string const& eventName, float volume, float fadeoutSeconds, ::MusicRepeatMode playMode);


    MCAPI void $setMusicCommandVolumeMultiplier(float volumeMultiplier);


    MCAPI void $stopCustomMusic(float fadeoutSeconds);


    MCAPI ::EntityContext& $getEntity() const;


    MCAPI ::AppSystemRegistry& $getAppSystemRegistry();


    MCAPI void $onLanguageChanged(::std::string const& code, bool languageSystemInitializing);


    MCFOLD void $onLanguageKeywordsLoadedFromPack(::PackManifest const&);


    MCFOLD void $onLanguagesLoaded();


    MCAPI void $buildTreatmentPackStack(bool fireEvents) const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelDbEnv> $getLevelDbEnv();


    MCAPI ::Bedrock::NonOwnerPointer<::ChunkSource> $getClientGenChunkSource(::DimensionType const& dimensionType);


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ProfanityContext> $getProfanityContext();


    MCAPI double $getGameUpdateDurationInSeconds() const;


    MCAPI void $queueSubclientRemoval(::SubClientId subid);


    MCAPI void $logoffAllSubclients();


    MCAPI void $setIsInGame(bool isInGame);


    MCAPI void $createClientItemRegistry();


    MCAPI ::Bedrock::NonOwnerPointer<::MinecraftInputHandler> $getInput() const;


    MCAPI ::std::unique_ptr<::LocalServerLauncher::IGameInterface> $createGameInterface();


    MCAPI ::std::unique_ptr<::LocalServerLauncher::IServerInstanceBuilder> $createServerBuilder();


    MCAPI ::std::unique_ptr<::LocalServerLauncher::GameDependencies> $createGameDependencies();


    MCAPI ::TaskGroup& $_getServerInitTaskGroup();


    MCAPI bool $checkMultiPlayerPermission(::std::optional<::Social::MultiplayerServiceIdentifier> service);


    MCAPI bool $isPlayingLevel() const;


    MCAPI void $initImpl();


    MCAPI void $refocusMouse(bool lostMouse);


    MCAPI void $setMouseType(::Bedrock::Input::PointerType type);


    MCAPI void $onNotify(::edu::auth::CredentialsAcquired const& state);


    MCFOLD void $onNotify(::edu::auth::CredentialsRefreshSuccess const& state);


    MCFOLD void $onNotify(::edu::auth::GenericCredentialsEvent<::edu::auth::CredsLost> const& state);


    MCAPI bool $checkForPiracy() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::DevConsoleLogger> $getDevConsoleLogger() const;


    MCAPI void $completeServerStartup(

        ::std::shared_ptr<::LocalServerLauncher::ServerInitData> serverInitData,

        ::LocalServerLauncher::ServerLaunchResult&&              result

    );

    // NOLINTEND


public:

    // vftables

    // NOLINTBEGIN

    MCNAPI static void** $vftableForIMultiPlayerServices();


    MCNAPI static void** $vftableForI18nObserver();


    MCNAPI static void** $vftableForIMinecraftApp();


    MCNAPI static void** $vftableForAppExtensionsOwner();


    MCNAPI static void** $vftableForAppPlatformListener();


    MCNAPI static void** $vftableForILocalServerLauncherImpl();


    MCNAPI static void** $vftableForLevelListener();


    MCNAPI static void** $vftableForIGameServerStartup();


    MCNAPI static void** $vftableForOptionsObserver();


    MCNAPI static void** $vftableForIGameEventNotifier();


    MCNAPI static void** $vftableForCredentialsObserver();


    MCNAPI static void** $vftableForISplitScreenChangedPublisher();


    MCNAPI static void** $vftableForIGameServerShutdown();


    MCNAPI static void** $vftableForEnableNonOwnerReferences();


    MCNAPI static void** $vftableForIWorldTransfer();


    MCNAPI static void** $vftableForIApp();


    MCNAPI static void** $vftableForResourcePackListener();


    MCNAPI static void** $vftableForIClientInstances();


    MCNAPI static void** $vftableForINetworkGameConnector();


    MCNAPI static void** $vftableForAppIsland();

    // NOLINTEND

};

ActiveDirectoryIdentity
Definition ActiveDirectoryIdentity.h:39

ActorAnimationControllerGroup
Definition ActorAnimationControllerGroup.h:27

ActorAnimationGroup
Definition ActorAnimationGroup.h:26

ActorResourceDefinitionGroup
Definition ActorResourceDefinitionGroup.h:5

AppSystemRegistry
Definition AppSystemRegistry.h:15

App
Definition App.h:9

Automation::AutomationClient
Definition AutomationClient.h:27

Bedrock::ActivationArguments
Definition ActivationArguments.h:7

Bedrock::PubSub::Subscription
Definition Subscription.h:10

Bedrock::ScopeExit
Definition ScopeExit.h:7

BlockCullingGroup
Definition BlockCullingGroup.h:5

ChunkSource
Definition ChunkSource.h:37

ClientBlobCache::Cache
Definition Cache.h:7

ClientBlockPipeline::SchematicsRepository
Definition SchematicsRepository.h:7

ClientInstance
Definition ClientInstance.h:5

ClientNetworkSystem
Definition ClientNetworkSystem.h:39

ClubsService
Definition ClubsService.h:5

ContentAcquisition
Definition ContentAcquisition.h:5

ContentCatalogService
Definition ContentCatalogService.h:5

ContentIdentity
Definition ContentIdentity.h:8

ContentLogFileEndPoint
Definition ContentLogFileEndPoint.h:16

Core::FilePathManager
Definition FilePathManager.h:18

Core::Path
Definition Path.h:12

CubemapBackgroundResources
Definition CubemapBackgroundResources.h:5

DateManager
Definition DateManager.h:14

DeferredLighting
Definition DeferredLighting.h:5

DevConsoleLogger
Definition DevConsoleLogger.h:5

EDUSystems
Definition EDUSystems.h:33

EmoticonManager
Definition EmoticonManager.h:5

EntityContext
Definition EntityContext.h:17

ExternalContentManager
Definition ExternalContentManager.h:5

FileArchiver
Definition FileArchiver.h:36

FlightingService
Definition FlightingService.h:5

FontHandle
Definition FontHandle.h:5

GameModuleClient
Definition GameModuleClient.h:5

GameRenderer
Definition GameRenderer.h:5

GatheringManager
Definition GatheringManager.h:5

GeometryGroup
Definition GeometryGroup.h:5

GlobalResourcesCrashRecovery
Definition GlobalResourcesCrashRecovery.h:5

GuiData
Definition GuiData.h:5

I18nObserver
Definition I18nObserver.h:14

IApp
Definition IApp.h:8

IClientDimensionExtensions
Definition IClientDimensionExtensions.h:5

IClientInstance
Definition IClientInstance.h:5

IContentAccessibilityProvider
Definition IContentAccessibilityProvider.h:13

IContentKeyProvider
Definition IContentKeyProvider.h:13

IContentManager
Definition IContentManager.h:5

IContentTierManager
Definition IContentTierManager.h:13

IDlcValidation
Definition IDlcValidation.h:5

IExternalServerFile
Definition IExternalServerFile.h:5

IGameModuleApp
Definition IGameModuleApp.h:5

IGameModuleShared
Definition IGameModuleShared.h:15

ILevelListCache
Definition ILevelListCache.h:27

IMinecraftEventing
Definition IMinecraftEventing.h:138

IMinecraftGame
Definition IMinecraftGame.h:5

IMultiPlayerServices
Definition IMultiPlayerServices.h:5

IResourcePackRepository
Definition IResourcePackRepository.h:34

ISceneStack
Definition ISceneStack.h:5

ITextBoxController
Definition ITextBoxController.h:5

IUIDefRepository
Definition IUIDefRepository.h:5

IUIRepository
Definition IUIRepository.h:5

ItemRegistryRef
Definition ItemRegistryRef.h:42

LatencyGraphDisplay
Definition LatencyGraphDisplay.h:5

LevelDbEnv
Definition LevelDbEnv.h:8

LevelListener
Definition LevelListener.h:28

LevelLoader
Definition LevelLoader.h:5

LevelSettings
Definition LevelSettings.h:40

LibraryRepository
Definition LibraryRepository.h:5

LinkedAssetValidator
Definition LinkedAssetValidator.h:8

LocalPlayer
Definition LocalPlayer.h:5

LocalServerLauncher::IGameInterface
Definition IGameInterface.h:7

LocalServerLauncher::ILocalServerLauncherImpl
Definition ILocalServerLauncherImpl.h:7

LocalServerLauncher::IServerInstanceBuilder
Definition IServerInstanceBuilder.h:7

MinecraftGame
Definition MinecraftGame.h:5

MinecraftGame::$vftableForIMinecraftApp
static MCAPI void ** $vftableForIMinecraftApp()

MinecraftGame::$vftableForIGameServerShutdown
static MCAPI void ** $vftableForIGameServerShutdown()

MinecraftGame::$vftableForAppPlatformListener
static MCAPI void ** $vftableForAppPlatformListener()

MinecraftGame::$vftableForINetworkGameConnector
static MCAPI void ** $vftableForINetworkGameConnector()

MinecraftGame::$vftableForI18nObserver
static MCAPI void ** $vftableForI18nObserver()

MinecraftGame::$vftableForIGameServerStartup
static MCAPI void ** $vftableForIGameServerStartup()

MinecraftGame::$vftableForLevelListener
static MCAPI void ** $vftableForLevelListener()

MinecraftGame::$vftableForILocalServerLauncherImpl
static MCAPI void ** $vftableForILocalServerLauncherImpl()

MinecraftGame::$vftableForIApp
static MCAPI void ** $vftableForIApp()

MinecraftGame::$vftableForIWorldTransfer
static MCAPI void ** $vftableForIWorldTransfer()

MinecraftGame::$vftableForAppExtensionsOwner
static MCAPI void ** $vftableForAppExtensionsOwner()

MinecraftGame::$vftableForResourcePackListener
static MCAPI void ** $vftableForResourcePackListener()

MinecraftGame::$vftableForEnableNonOwnerReferences
static MCAPI void ** $vftableForEnableNonOwnerReferences()

MinecraftGame::$vftableForAppIsland
static MCAPI void ** $vftableForAppIsland()

MinecraftGame::$vftableForIMultiPlayerServices
static MCAPI void ** $vftableForIMultiPlayerServices()

MinecraftGame::$vftableForIGameEventNotifier
static MCAPI void ** $vftableForIGameEventNotifier()

MinecraftGame::$vftableForCredentialsObserver
static MCAPI void ** $vftableForCredentialsObserver()

MinecraftGame::$vftableForOptionsObserver
static MCAPI void ** $vftableForOptionsObserver()

MinecraftGame::$vftableForIClientInstances
static MCAPI void ** $vftableForIClientInstances()

MinecraftGame::$vftableForISplitScreenChangedPublisher
static MCAPI void ** $vftableForISplitScreenChangedPublisher()

MinecraftGraphics
Definition MinecraftGraphics.h:5

MinecraftInputHandler
Definition MinecraftInputHandler.h:5

Minecraft
Definition Minecraft.h:61

MusicManager
Definition MusicManager.h:5

NewPlayerSystem
Definition NewPlayerSystem.h:5

OptionRegistry
Definition OptionRegistry.h:5

Option
Definition Option.h:22

OptionsObserver
Definition OptionsObserver.h:5

OreUI::DataProviderManager_DEPRECATED
Definition DataProviderManager_DEPRECATED.h:7

OreUI::IResourceAllowList
Definition IResourceAllowList.h:7

OreUI::Router
Definition Router.h:7

PackDownloadManager
Definition PackDownloadManager.h:5

PackManifestFactory
Definition PackManifestFactory.h:21

PackManifest
Definition PackManifest.h:38

PackSourceFactory
Definition PackSourceFactory.h:34

ParticleEffectGroup
Definition ParticleEffectGroup.h:5

Parties::PartySystem
Definition PartySystem.h:7

PersonaRepository
Definition PersonaRepository.h:5

PersonaService
Definition PersonaService.h:5

PixelCalc
Definition PixelCalc.h:5

PlayerMessagingService
Definition PlayerMessagingService.h:5

Player
Definition Player.h:137

ProfanityContext
Definition ProfanityContext.h:5

Progress::ProgressTips
Definition ProgressTips.h:7

PushNotificationMessage
Definition PushNotificationMessage.h:5

RealmsAPI
Definition RealmsAPI.h:5

Realms::ContentService
Definition ContentService.h:7

Realms::GenericRequestServiceHandler
Definition GenericRequestServiceHandler.h:7

Realms::RealmsServices
Definition RealmsServices.h:7

Realms::RealmsSystem
Definition RealmsSystem.h:7

Realms::SubscriptionService
Definition SubscriptionService.h:7

RenderControllerGroup
Definition RenderControllerGroup.h:5

ResetCallbackObject
Definition ResetCallbackObject.h:5

ResourceLoadManager
Definition ResourceLoadManager.h:19

ResourcePackListener
Definition ResourcePackListener.h:10

ResourcePackManager
Definition ResourcePackManager.h:35

ResourcePackStack
Definition ResourcePackStack.h:24

SceneFactory
Definition SceneFactory.h:5

ScreenshotRecorder
Definition ScreenshotRecorder.h:5

SeasonsRenderer
Definition SeasonsRenderer.h:5

SerialWorkList
Definition SerialWorkList.h:5

ServerInstanceEventCoordinator
Definition ServerInstanceEventCoordinator.h:20

ServerInstance
Definition ServerInstance.h:64

ServerNetworkHandler
Definition ServerNetworkHandler.h:184

SkinRepository
Definition SkinRepository.h:5

Social::GameConnectionInfo
Definition GameConnectionInfo.h:23

Social::IUserManager
Definition IUserManager.h:7

Social::MultiplayerGameInfo
Definition MultiplayerGameInfo.h:7

Social::MultiplayerServiceManager
Definition MultiplayerServiceManager.h:7

Social::PresenceManager
Definition PresenceManager.h:7

Social::SocialSystem
Definition SocialSystem.h:7

Social::User
Definition User.h:7

SoundEngine
Definition SoundEngine.h:5

SunsettingManager
Definition SunsettingManager.h:5

TaskGroup
Definition TaskGroup.h:55

TextToIconMapper
Definition TextToIconMapper.h:5

TextureAtlas
Definition TextureAtlas.h:5

Timer
Definition Timer.h:5

TreatmentPackDownloadMonitor
Definition TreatmentPackDownloadMonitor.h:5

TrialManager
Definition TrialManager.h:5

UIMeasureStrategy
Definition UIMeasureStrategy.h:5

Vec3
Definition Vec3.h:10

WorldTemplateManager
Definition WorldTemplateManager.h:22

WorldTransferAgent
Definition WorldTransferAgent.h:5

World::WorldSystem
Definition WorldSystem.h:7

mce::TextureGroup
Definition TextureGroup.h:7

mce::UUID
Definition UUID.h:7

ActorUniqueID
Definition ActorUniqueID.h:10

ControllerIDtoClientMap
Definition ControllerIDtoClientMap.h:5

DimensionType
Definition DimensionType.h:5

ExperienceConnectionData
Definition ExperienceConnectionData.h:5

ExternalWorldTransferActionFunc
Definition ExternalWorldTransferActionFunc.h:5

GameConnectionInfoEx
Definition GameConnectionInfoEx.h:5

LocalServerLauncher::GameDependencies
Definition GameDependencies.h:7

LocalServerLauncher::Impl::AllDependencies
Definition AllDependencies.h:7

LocalServerLauncher::ServerInitData
Definition ServerInitData.h:7

LocalServerLauncher::ServerLaunchResult
Definition ServerLaunchResult.h:7

LocalWorldTransferActionFunc
Definition LocalWorldTransferActionFunc.h:5

MinecraftGameArguments
Definition MinecraftGameArguments.h:5

MinecraftGame::FrameGapImpl
Definition MinecraftGame.h:27

MinecraftGame::InitContext
Definition MinecraftGame.h:23

MinecraftGame::TestCommandPublisher
Definition MinecraftGame.h:25

PlayerJoinWorldContext
Definition PlayerJoinWorldContext.h:5

RealmTransferActionFunc
Definition RealmTransferActionFunc.h:5

Realms::RealmId
Definition RealmId.h:7

Realms::World
Definition World.h:7

ScreenshotOptions
Definition ScreenshotOptions.h:9

dragon::framerenderer::DebugParameters
Definition DebugParameters.h:7

edu::auth::CredentialsAcquired
Definition CredentialsAcquired.h:7

edu::auth::CredentialsObserver
Definition CredentialsObserver.h:7

edu::auth::CredentialsRefreshSuccess
Definition CredentialsRefreshSuccess.h:7

edu::auth::CredsLost
Definition CredsLost.h:7