d9/da2/Level_8h_source.html

#pragma once


#include "mc/_HeaderOutputPredefine.h"


// auto generated inclusion list

#include "mc/common/SubClientId.h"

#include "mc/comprehensive/ParticleType.h"

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

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

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

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

#include "mc/deps/core/utility/pub_sub/Subscription.h"

#include "mc/deps/game_refs/OwnerPtr.h"

#include "mc/deps/game_refs/StackRefResult.h"

#include "mc/deps/game_refs/WeakRef.h"

#include "mc/deps/shared_types/legacy/Difficulty.h"

#include "mc/deps/shared_types/legacy/LevelEvent.h"

#include "mc/deps/shared_types/legacy/LevelSoundEvent.h"

#include "mc/network/GamePublishSetting.h"

#include "mc/platform/Result.h"

#include "mc/server/commands/CurrentCmdVersion.h"

#include "mc/util/Factory.h"

#include "mc/util/IDType.h"

#include "mc/util/OwnerPtrFactory.h"

#include "mc/util/TagRegistry.h"

#include "mc/world/actor/ActorEvent.h"

#include "mc/world/item/registry/ItemRegistryRef.h"

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

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

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

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

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

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

#include "mc/world/level/biome/glue/BiomeJsonDocumentGlue.h"

#include "mc/world/level/storage/StorageVersion.h"


// auto generated forward declare list

// clang-format off

class Abilities;

class Actor;

class ActorAnimationControllerGroup;

class ActorAnimationGroup;

class ActorDamageSource;

class ActorDefinitionGroup;

class ActorDimensionTransferManager;

class ActorEventBroadcaster;

class ActorEventCoordinator;

class ActorFactory;

class ActorFetcher;

class ActorGarbageCollector;

class ActorInfoRegistry;

class ActorManager;

class ActorRuntimeID;

class ActorRuntimeIDManager;

class ActorSoundIdentifier;

class ArmorTrimUnloader;

class AutomationBehaviorTreeGroup;

class AutonomousActorManager;

class BaseLightTextureImageBuilder;

class BehaviorFactory;

class BiomeComponentFactory;

class BiomeManager;

class BiomeRegistry;

class Block;

class BlockActorLevelListener;

class BlockChangeContext;

class BlockDefinitionGroup;

class BlockEventCoordinator;

class BlockPalette;

class BlockPos;

class BlockReducer;

class BlockSource;

class BlockType;

class BlockTypeRegistry;

class BossEventSubscriptionManager;

class CameraPresets;

class CameraRegistry;

class ChangeDimensionRequest;

class ChunkGenerationManager;

class ChunkPos;

class ChunkSource;

class ChunkTickOffsetManager;

class ChunkTickRangeManager;

class ChunkViewSource;

class ChunkViewTrackerManager;

class ClientPlayerEventCoordinator;

class Command;

class CommandOrigin;

class CompoundTag;

class ContainerRegistry;

class Dimension;

class DimensionConversionData;

class DimensionDefinitionGroup;

class DimensionFactory;

class DimensionManager;

class DisplayActorManager;

class EducationSettingsManager;

class EntityContext;

class EntityRegistry;

class EntitySystems;

class EntitySystemsManager;

class EventCoordinatorManager;

class Experiments;

class Explosion;

class FeatureRegistry;

class FeatureTypeFactory;

class GameRules;

class GameplayUserManager;

class HashedString;

class HitResult;

class HitResultWrapper;

class IConstBlockSource;

class IEntityRegistryOwner;

class ILevelRandom;

class IMinecraftEventing;

class IRandom;

class IUnknownBlockTypeRegistry;

class InternalComponentRegistry;

class ItemEventCoordinator;

class JigsawStructureRegistry;

class LayeredAbilities;

class LevelBlockDestroyer;

class LevelChunk;

class LevelChunkEventManager;

class LevelChunkMetaDataManager;

class LevelChunkPerformanceTelemetry;

class LevelChunkSaveManager;

class LevelCrashDumpManager;

class LevelData;

class LevelEventCoordinator;

class LevelEventManager;

class LevelListener;

class LevelSeed64;

class LevelSettings;

class LevelSoundManager;

class LevelStorage;

class LevelStorageManager;

class LinkedAssetValidator;

class LoadingScreenIdManager;

class LootTables;

class MapItemSavedData;

class Mob;

class MolangPackSettingsCache;

class MolangVariableMap;

class NavigationComponent;

class NetEventCallback;

class NetworkIdentifier;

class NpcDialogueStorage;

class PacketSender;

class Particle;

class ParticleProvider;

class Path;

class PauseManager;

class PermissionsHandler;

class PhotoItemSavedDataCollection;

class PhotoManager;

class PhotoStorage;

class Player;

class PlayerAbilitiesManager;

class PlayerDeathManager;

class PlayerDimensionTransferManager;

class PlayerEventCoordinator;

class PlayerLimboActorManager;

class PlayerListEntry;

class PlayerListManager;

class PlayerLocationReceiver;

class PlayerLocationSender;

class PlayerMovementSettingsManager;

class PlayerPermissionsManager;

class PlayerPermissionsSynchroniser;

class PlayerSleepManager;

class PlayerTickManager;

class PortalForcer;

class ProjectileFactory;

class PropertyGroupManager;

class Random;

class Recipes;

class ResourcePackManager;

class SavedDataStorage;

class Scheduler;

class Scoreboard;

class ScriptDeferredEventCoordinator;

class ScriptingEventCoordinator;

class SerializedSkin;

class ServerLevelEventCoordinator;

class ServerNetworkEventCoordinator;

class ServerParticleManager;

class ServerPlayerEventCoordinator;

class ServerPlayerSleepManager;

class SoundPlayerInterface;

class Spawner;

class StartGamePacket;

class StrictEntityContext;

class StructureManager;

class StructureSpawnRegistry;

class SubChunkManager;

class SubChunkPacket;

class SubChunkRequestManager;

class SurfaceBuilderRegistry;

class TagCacheManager;

class TaskGroup;

class TempEPtrManager;

class TickDeathSettingsManager;

class TickDeltaTimeManager;

class TickTimeManager;

class TickingAreaList;

class TickingAreasManager;

class TradeTables;

class TrimMaterialRegistry;

class TrimPatternRegistry;

class TrustedSkinHelper;

class UniqueIDManager;

class UserEntityIdentifierComponent;

class VanillaActorEventListenerManager;

class Vec3;

class VolumeEntityManagerServer;

class WeakEntityRef;

class WeatherManager;

class _TickPtr;

struct ActorUniqueID;

struct AdventureSettings;

struct Bounds;

struct BreakingItemParticleData;

struct DerivedDimensionArguments;

struct LevelTagIDType;

struct LevelTagSetIDType;

struct NetworkPermissions;

struct PlayerMovementSettings;

struct PlayerSleepStatus;

struct ResolvedItemIconInfo;

struct ScreenshotOptions;

struct Tick;

struct TickDeathSettings;

namespace PlayerCapabilities { struct ISharedController; }

namespace PositionTrackingDB { class PositionTrackingDBClient; }

namespace PositionTrackingDB { class PositionTrackingDBServer; }

namespace SharedTypes::v1_21_90 { struct CameraPreset; }

namespace VoxelShapes { class VoxelShapeRegistry; }

namespace cereal { struct ReflectionCtx; }

namespace cg { class ImageBuffer; }

namespace mce { class Color; }

namespace mce { class UUID; }

// clang-format on


class ServerLevel;


class Level : public ::ILevel, public ::BlockSourceListener, public ::IWorldRegistriesProvider {

public:

    [[nodiscard]] ServerLevel& asServer() { return *reinterpret_cast<ServerLevel*>(this); }


public:

    // Level inner types define

    using RegionSet = ::std::unordered_set<::BlockSource*>;


public:

    // member variables

    // NOLINTBEGIN

    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::PacketSender> const> mPacketSender;

    ::ll::TypedStorage<

        8,

        16,

        ::gsl::not_null<

            ::Bedrock::UniqueOwnerPointer<::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>>>>

                                                                                  mTagRegistry;

    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::ActorInfoRegistry>>             mActorInfoRegistry;

    ::ll::TypedStorage<8, 24, ::std::vector<::LevelListener*>>                    mListeners;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::LevelStorageManager>>            mLevelStorageManager;

    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::LevelData> const>   mLevelData;

    ::ll::TypedStorage<8, 64, ::std::unordered_set<::BlockSource*>>               mRegions;

    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::LinkedAssetValidator>> mLinkedAssetValidator;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ActorDefinitionGroup>>           mEntityDefinitions;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ActorAnimationGroup>>            mActorAnimationGroup;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ActorAnimationControllerGroup>>  mActorAnimationControllerGroup;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::BlockDefinitionGroup>>           mBlockDefinitions;

    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::TrimPatternRegistry>>           mTrimPatternRegistry;

    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::TrimMaterialRegistry>>          mTrimMaterialRegistry;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Spawner>>                        mMobSpawner;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ProjectileFactory>>              mProjectileFactory;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::PropertyGroupManager>>           mActorPropertyGroups;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::CameraPresets>>                  mCameraPresets;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::BehaviorFactory>>                mBehaviorFactory;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::AutomationBehaviorTreeGroup>>    mAutomationBehaviorTreeDefinitions;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::BlockPalette>>                   mGlobalBlockPalette;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Recipes>>                        mRecipes;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::BlockReducer>>                   mBlockReducer;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::NpcDialogueStorage>>             mNpcDialogueStorage;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::InternalComponentRegistry>>      mInternalComponentRegistry;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PortalForcer>>> mPortalForcer;

    ::ll::TypedStorage<8, 16, ::ItemRegistryRef const>                                        mItemRegistry;

    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::BlockTypeRegistry>>             mBlockTypeRegistry;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::IUnknownBlockTypeRegistry>>                  mUnknownBlockTypeRegistry;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::BossEventSubscriptionManager>>       mBossEventSubscriptionManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::OwnerPtr<::ContainerRegistry>> const> mContainerRegistry;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::HitResultWrapper>>> mHitResultWrapper;

    ::ll::TypedStorage<8, 32, ::std::string>                                  mImmersiveReaderString;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::OwnerPtr<::ILevelRandom>>>    mLevelRandom;

    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::NetEventCallback>> mNetEventCallback;

    ::ll::TypedStorage<1, 1, bool const>                                      mIsClientSide;

    ::ll::TypedStorage<1, 1, ::SubClientId>                                   mSubClientId;

    ::ll::TypedStorage<1, 1, bool>                                            mIsExporting;

    ::ll::TypedStorage<1, 1, bool>                                            mDisablePlayerInteractions;

    ::ll::TypedStorage<1, 1, bool>                                            mSimPaused;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::TaskGroup>>                  mMainThreadTaskGroup;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::TaskGroup>>                  mIOTaskGroup;

    ::ll::TypedStorage<8, 8, ::Scheduler&>                                    mScheduler;

    ::ll::TypedStorage<8, 32, ::std::string>                                  mLevelId;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::TickingAreasManager>>        mTickingAreasMgr;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::TempEPtrManager>>> mTempEPtrManager;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::PhotoItemSavedDataCollection>> mPhotoItemSavedDataCollection;

    ::ll::TypedStorage<1, 1, bool>                                              mTearingDown;

    ::ll::TypedStorage<8, 8, ::IMinecraftEventing&>                             mEventing;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::EventCoordinatorManager>>>

                                                                                 mEventCoordinatorManager;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::LevelSoundManager>>             mLevelSoundManager;

    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::StructureManager>> mStructureManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::LevelChunkPerformanceTelemetry>>>

                                                              mLevelChunkPerformanceTelemetry;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::LootTables>> mLootTables;

    ::ll::TypedStorage<8, 8, ::BlockType const*>              mRegisteredBorderBlock;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::JigsawStructureRegistry>>>

        mJigsawStructureRegistry;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::StructureSpawnRegistry>>>

        mStructureSpawnRegistry;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::DimensionFactory>>> mDimensionFactory;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::DimensionManager>>> mDimensionManager;

    ::ll::TypedStorage<8, 24, ::WeakRef<::EntityContext>>                                         mLevelEntity;

    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::IEntityRegistryOwner>>              mEntityRegistryOwner;

    ::ll::TypedStorage<8, 16, ::OwnerPtr<::PauseManager>>                                         mPauseManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::OwnerPtr<::EntitySystemsManager>>>                mEntitySystemsManager;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::FeatureRegistry>>                                mFeatureRegistry;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::FeatureTypeFactory>>                             mFeatureTypeFactory;

    ::ll::TypedStorage<8, 64, ::Factory<::BaseLightTextureImageBuilder, ::Level&, ::Scheduler&>>

        mLightTextureImageBuilderFactory;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::EducationSettingsManager>>>

                                                                                         mEducationSettingsManager;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::PlayerCapabilities::ISharedController>> mCapabilities;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::BlockActorLevelListener>>               mBlockActorLevelListener;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::VanillaActorEventListenerManager>> mVanillaActorEventListenerManager;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::PositionTrackingDB::PositionTrackingDBClient>>

                                                                mPositionTrackerDBClient;

    ::ll::TypedStorage<1, 1, bool>                              mClientSideChunkGenEnabled;

    ::ll::TypedStorage<1, 1, bool>                              mBlockNetworkIdsAreHashes;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::BiomeManager>> mBiomeManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ActorGarbageCollector>>>

                                                                                              mActorGarbageCollector;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ActorManager>>> mActorManager;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnRemoveActorEntityReferences;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::AutonomousActorManager>>>

                                                                                              mAutonomousActorManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ActorFetcher>>> mActorFetcher;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::GameplayUserManager>>>

                                                                            mGameplayUserManager;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription>              mOnGameplayUserAddedSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription>              mOnGameplayUserRemovedSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription>              mOnAnyGameplayUsersRemovedSubscription;

    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::Scoreboard>>               mScoreboard;

    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::MolangPackSettingsCache>> mMolangPackSettingsCache;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ActorRuntimeIDManager>>>

                                                                                       mActorRuntimeIDManager;

    ::ll::TypedStorage<8, 16, ::Bedrock::UniqueOwnerPointer<::PlayerLocationReceiver>> mPlayerLocationReceiver;

    ::ll::TypedStorage<8, 16, ::Bedrock::UniqueOwnerPointer<::PlayerLocationSender>>   mPlayerLocationSender;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PlayerListManager>>> mPlayerListManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PlayerTickManager>>> mPlayerTickManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ServerParticleManager>>>

        mServerParticleManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ParticleProvider>>> mParticleProvider;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnSendServerLegacyParticleSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnAddTerrainParticleEffectSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnAddTerrainSlideEffectSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnAddBreakingItemParticleEffectSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnAddBiomeTintedParticleEffectSubscription;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ChunkTickRangeManager>>>

        mChunkTickRangeManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ChunkViewTrackerManager>>>

                                                                                              mChunkViewTrackerManager;

    ::ll::TypedStorage<8, 16, ::Bedrock::UniqueOwnerPointer<::ActorEventBroadcaster> const>   mActorEventBroadcaster;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::OwnerPtr<::cereal::ReflectionCtx>>>           mCerealContext;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ActorFactory>>> mActorFactory;

    ::ll::TypedStorage<8, 16, ::Bedrock::UniqueOwnerPointer<::LoadingScreenIdManager>>        mLoadingScreenIdManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PlayerDimensionTransferManager>>>

        mPlayerDimensionTransferManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::LevelCrashDumpManager>> const>

                                                                              mLevelCrashDumpManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::OwnerPtr<::UniqueIDManager>>> mUniqueIDManager;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription>                mOnPictureTakenSubscription;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PhotoManager>>>      mPhotoManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::LevelEventManager>>> mLevelEventManager;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mLevelEventDataSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mLevelEventCompoundTagSubscription;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ChunkTickOffsetManager>>>

        mChunkTickOffsetManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PlayerMovementSettingsManager>>>

        mPlayerMovementSettingsManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::TickDeathSettingsManager>>>

        mTickDeathSettingsManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PlayerAbilitiesManager>>>

        mPlayerAbilitiesManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PlayerPermissionsManager>>>

        mPlayerPermissionsManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::PlayerPermissionsSynchroniser>>>

        mPlayerPermissionsSynchroniser;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::LevelChunkEventManager>>>

                                                               mLevelChunkEventManager;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnChunkLoadedSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnChunkReloadedSubscription;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnChunkDiscardedSubscription;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::ActorDimensionTransferManager>>>

        mActorDimensionTransferManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::LevelBlockDestroyer>>>

        mLevelBlockDestroyer;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::Bedrock::UniqueOwnerPointer<::TickDeltaTimeManager>>>

                                                                                    mTickDeltaTimeManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::OwnerPtr<::TickTimeManager>>>       mTickTimeManager;

    ::ll::TypedStorage<8, 16, ::OwnerPtr<::LevelChunkSaveManager>>                  mLevelChunkSaveManager;

    ::ll::TypedStorage<8, 16, ::gsl::not_null<::OwnerPtr<::WeatherManager>>>        mWeatherManager;

    ::ll::TypedStorage<1, 1, ::std::atomic<bool>>                                   mHandleLowMemoryOnTick;

    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription>                      mLowMemorySubscription;

    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::VoxelShapes::VoxelShapeRegistry>> mShapeRegistry;

    // NOLINTEND


public:

    // prevent constructor by default

    Level& operator=(Level const&);

    Level(Level const&);

    Level();


public:

    // virtual functions

    // NOLINTBEGIN

    // vIndex: 0

    virtual ~Level() /*override*/;


    // vIndex: 1

    virtual bool initialize(

        ::std::string const&   levelName,

        ::LevelSettings const& levelSettings,

        ::Experiments const&   experiments,

        ::std::string const*   levelId,

        ::std::optional<::std::reference_wrapper<

            ::std::unordered_map<::std::string, ::std::unique_ptr<::BiomeJsonDocumentGlue::ResolvedBiomeData>>>>

            biomeIdToResolvedData

    ) /*override*/;


    // vIndex: 2

    virtual void startLeaveGame() /*override*/;


    // vIndex: 3

    virtual bool isLeaveGameDone() /*override*/;


    // vIndex: 4

    virtual ::WeakRef<::Dimension> getOrCreateDimension(::DimensionType dimensionType) /*override*/;


    // vIndex: 5

    virtual ::WeakRef<::Dimension> getDimension(::DimensionType id) const /*override*/;


    // vIndex: 6

    virtual ::DimensionType getLastOrDefaultSpawnDimensionId(::DimensionType lastDimensionId) const /*override*/;


    // vIndex: 8

    virtual void forEachDimension(::std::function<bool(::Dimension&)> callback) /*override*/;


    // vIndex: 7

    virtual void forEachDimension(::std::function<bool(::Dimension const&)> callback) const /*override*/;


    // vIndex: 11

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


    // vIndex: 12

    virtual ::ChunkTickRangeManager const& getChunkTickRangeManager() const /*override*/;


    // vIndex: 13

    virtual ::PortalForcer& getPortalForcer() /*override*/;


    // vIndex: 14

    virtual void requestPlayerChangeDimension(::Player& player, ::ChangeDimensionRequest&& changeRequest) /*override*/;


    // vIndex: 15

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerDimensionTransferManager>

    getPlayerDimensionTransferManager() /*override*/;


    // vIndex: 16

    virtual void

    entityChangeDimension(::Actor& entity, ::DimensionType toId, ::std::optional<::Vec3> entityPos) /*override*/;


    // vIndex: 17

    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorDimensionTransferManager>

    getActorDimensionTransferManager() /*override*/;


    // vIndex: 18

    virtual ::Spawner& getSpawner() const /*override*/;


    // vIndex: 19

    virtual ::Bedrock::NotNullNonOwnerPtr<::BossEventSubscriptionManager>

    getBossEventSubscriptionManager() /*override*/;


    // vIndex: 20

    virtual ::ProjectileFactory& getProjectileFactory() const /*override*/;


    // vIndex: 21

    virtual ::ActorDefinitionGroup* getEntityDefinitions() const /*override*/;


    // vIndex: 22

    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationGroup> getActorAnimationGroup() const /*override*/;


    // vIndex: 23

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

        /*override*/;


    // vIndex: 24

    virtual ::BlockDefinitionGroup* getBlockDefinitions() const /*override*/;


    // vIndex: 25

    virtual ::PropertyGroupManager& getActorPropertyGroup() const /*override*/;


    // vIndex: 27

    virtual ::CameraPresets const& getCameraPresets() const /*override*/;


    // vIndex: 26

    virtual ::CameraPresets& getCameraPresets() /*override*/;


    // vIndex: 28

    virtual ::SharedTypes::v1_21_90::CameraPreset const* getCameraPreset(int presetIndex) const /*override*/;


    // vIndex: 29

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


    // vIndex: 30

    virtual void setDisablePlayerInteractions(bool const disable) /*override*/;


    // vIndex: 31

    virtual ::AutomationBehaviorTreeGroup& getAutomationBehaviorTreeGroup() const /*override*/;


    // vIndex: 32

    virtual ::BehaviorFactory& getBehaviorFactory() const /*override*/;


    // vIndex: 33

    virtual ::SharedTypes::Legacy::Difficulty getDifficulty() const /*override*/;


    // vIndex: 35

    virtual ::DimensionConversionData getDimensionConversionData() const /*override*/;


    // vIndex: 36

    virtual float getSpecialMultiplier(::DimensionType dimensionType) const /*override*/;


    // vIndex: 37

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


    // vIndex: 38

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


    // vIndex: 39

    virtual void setMsaGamertagsOnly(bool msaGamertagsOnly) /*override*/;


    // vIndex: 40

    virtual ::Actor* addEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity) /*override*/;


    // vIndex: 46

    virtual ::Actor* putEntity(

        ::BlockSource&              region,

        ::ActorUniqueID             id,

        ::ActorRuntimeID            runtimeId,

        ::OwnerPtr<::EntityContext> entity

    ) /*override*/;


    // vIndex: 45

    virtual ::Actor*

    putEntity(::BlockSource& region, ::ActorUniqueID id, ::OwnerPtr<::EntityContext> entity) /*override*/;


    // vIndex: 41

    virtual ::Actor* addGlobalEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity) /*override*/;


    // vIndex: 42

    virtual ::Actor* addAutonomousEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity) /*override*/;


    // vIndex: 43

    virtual void addUser(::OwnerPtr<::EntityContext> userEntity) /*override*/;


    // vIndex: 44

    virtual ::Actor* addDisplayEntity(::BlockSource&, ::OwnerPtr<::EntityContext>) /*override*/;


    // vIndex: 47

    virtual void removeDisplayEntity(::WeakEntityRef) /*override*/;


    // vIndex: 48

    virtual ::Bedrock::NonOwnerPointer<::DisplayActorManager> getDisplayActorManager() /*override*/;


    // vIndex: 49

    virtual void suspendPlayer(::Player& player) /*override*/;


    // vIndex: 50

    virtual void resumePlayer(::Player& player) /*override*/;


    // vIndex: 51

    virtual bool isPlayerSuspended(::Player& player) const /*override*/;


    // vIndex: 53

    virtual ::Bedrock::NotNullNonOwnerPtr<::GameplayUserManager> getGameplayUserManager() /*override*/;


    // vIndex: 52

    virtual ::Bedrock::NotNullNonOwnerPtr<::GameplayUserManager const> getGameplayUserManager() const /*override*/;


    // vIndex: 54

    virtual ::Bedrock::NonOwnerPointer<::PlayerLocationReceiver> getPlayerLocationReceiver() /*override*/;


    // vIndex: 55

    virtual ::OwnerPtr<::EntityContext> removeActorAndTakeEntity(::WeakEntityRef entityRef) /*override*/;


    // vIndex: 56

    virtual ::OwnerPtr<::EntityContext> removeActorFromWorldAndTakeEntity(::WeakEntityRef entityRef) /*override*/;


    // vIndex: 57

    virtual ::OwnerPtr<::EntityContext> takeEntity(::WeakEntityRef entityRef, ::LevelChunk& lc) /*override*/;


    // vIndex: 58

    virtual ::StrictEntityContext fetchStrictEntity(::ActorUniqueID actorId, bool getRemoved) const /*override*/;


    // vIndex: 59

    virtual ::Actor* fetchEntity(::ActorUniqueID actorId, bool getRemoved) const /*override*/;


    // vIndex: 60

    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorFetcher const> getActorFetcher() const /*override*/;


    // vIndex: 61

    virtual ::Actor* getRuntimeEntity(::ActorRuntimeID actorId, bool getRemoved) const /*override*/;


    // vIndex: 63

    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorRuntimeIDManager> getActorRuntimeIDManager() /*override*/;


    // vIndex: 62

    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorRuntimeIDManager const> getActorRuntimeIDManager() const /*override*/;


    // vIndex: 64

    virtual ::Mob* getMob(::ActorUniqueID mobId) const /*override*/;


    // vIndex: 67

    virtual ::Player* getPlayer(::std::string const& name) const /*override*/;


    // vIndex: 66

    virtual ::Player* getPlayer(::mce::UUID const& uuid) const /*override*/;


    // vIndex: 65

    virtual ::Player* getPlayer(::ActorUniqueID entityID) const /*override*/;


    // vIndex: 68

    virtual ::Player* getPlayerByXuid(::std::string const& xuid) const /*override*/;


    // vIndex: 69

    virtual ::Player* getPlatformPlayer(::std::string const& platformOnlineId) const /*override*/;


    // vIndex: 70

    virtual ::Player* getPlayerFromServerId(::std::string const& serverId) const /*override*/;


    // vIndex: 71

    virtual ::Player* getRuntimePlayer(::ActorRuntimeID runtimeId) const /*override*/;


    // vIndex: 72

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


    // vIndex: 73

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


    // vIndex: 74

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


    // vIndex: 75

    virtual ::mce::Color getPlayerColor(::Player const& player) const /*override*/;


    // vIndex: 76

    virtual ::Tick const& getCurrentTick() const /*override*/;


    // vIndex: 77

    virtual ::Tick const getCurrentServerTick() const /*override*/;


    // vIndex: 78

    virtual ::Bedrock::NotNullNonOwnerPtr<::TickDeltaTimeManager const> getTickDeltaTimeManager() const /*override*/;


    // vIndex: 390

    virtual ::ArmorTrimUnloader* getArmorTrimUnloader();


    // vIndex: 79

    virtual ::VoxelShapes::VoxelShapeRegistry const* getShapeRegistry() const /*override*/;


    // vIndex: 81

    virtual ::BiomeRegistry const& getBiomeRegistry() const /*override*/;


    // vIndex: 80

    virtual ::BiomeRegistry& getBiomeRegistry() /*override*/;


    // vIndex: 83

    virtual ::BlockPalette const& getBlockPalette() const /*override*/;


    // vIndex: 82

    virtual ::BlockPalette& getBlockPalette() /*override*/;


    // vIndex: 85

    virtual ::FeatureRegistry const& getFeatureRegistry() const /*override*/;


    // vIndex: 84

    virtual ::FeatureRegistry& getFeatureRegistry() /*override*/;


    // vIndex: 87

    virtual ::FeatureTypeFactory const& getFeatureTypeFactory() const /*override*/;


    // vIndex: 86

    virtual ::FeatureTypeFactory& getFeatureTypeFactory() /*override*/;


    // vIndex: 89

    virtual ::JigsawStructureRegistry const& getJigsawStructureRegistry() const /*override*/;


    // vIndex: 88

    virtual ::JigsawStructureRegistry& getJigsawStructureRegistry() /*override*/;


    // vIndex: 91

    virtual ::StructureSpawnRegistry const& getStructureSpawnRegistry() const /*override*/;


    // vIndex: 90

    virtual ::StructureSpawnRegistry& getStructureSpawnRegistry() /*override*/;


    // vIndex: 93

    virtual ::Bedrock::NotNullNonOwnerPtr<::StructureManager> const getStructureManager() const /*override*/;


    // vIndex: 92

    virtual ::Bedrock::NotNullNonOwnerPtr<::StructureManager> getStructureManager() /*override*/;


    // vIndex: 95

    virtual ::BiomeComponentFactory const& getBiomeComponentFactory() const /*override*/;


    // vIndex: 94

    virtual ::BiomeComponentFactory& getBiomeComponentFactory() /*override*/;


    // vIndex: 97

    virtual ::SurfaceBuilderRegistry const& getSurfaceBuilderRegistry() const /*override*/;


    // vIndex: 96

    virtual ::SurfaceBuilderRegistry& getSurfaceBuilderRegistry() /*override*/;


    // vIndex: 99

    virtual ::BiomeManager const& getBiomeManager() const /*override*/;


    // vIndex: 98

    virtual ::BiomeManager& getBiomeManager() /*override*/;


    // vIndex: 101

    virtual ::OwnerPtrFactory<::Dimension, ::DerivedDimensionArguments&&> const& getDimensionFactory() const

        /*override*/;


    // vIndex: 100

    virtual ::OwnerPtrFactory<::Dimension, ::DerivedDimensionArguments&&>& getDimensionFactory() /*override*/;


    // vIndex: 103

    virtual ::Factory<::BaseLightTextureImageBuilder, ::Level&, ::Scheduler&> const&

    getLightTextureImageBuilderFactory() const /*override*/;


    // vIndex: 102

    virtual ::Factory<::BaseLightTextureImageBuilder, ::Level&, ::Scheduler&>&

    getLightTextureImageBuilderFactory() /*override*/;


    // vIndex: 34

    virtual ::InternalComponentRegistry& getInternalComponentRegistry() const /*override*/;


    // vIndex: 105

    virtual ::IWorldRegistriesProvider const& getWorldRegistriesProvider() const /*override*/;


    // vIndex: 104

    virtual ::IWorldRegistriesProvider& getWorldRegistriesProvider() /*override*/;


    // vIndex: 106

    virtual void addListener(::LevelListener& listener) /*override*/;


    // vIndex: 107

    virtual void removeListener(::LevelListener& listener) /*override*/;


    // vIndex: 108

    virtual void tickEntities() /*override*/;


    // vIndex: 109

    virtual void tickEntitySystems() /*override*/;


    // vIndex: 112

    virtual void onPlayerDeath(::Player& player, ::ActorDamageSource const& source) /*override*/;


    // vIndex: 113

    virtual void tick() /*override*/;


    // vIndex: 115

    virtual bool explode(

        ::BlockSource& region,

        ::Actor*       source,

        ::Vec3 const&  pos,

        float          explosionRadius,

        bool           fire,

        bool           breaksBlocks,

        float          maxResistance,

        bool           allowUnderwater

    ) /*override*/;


    // vIndex: 114

    virtual bool explode(::Explosion& explosion) /*override*/;


    // vIndex: 118

    virtual void denyEffect(::BlockSource& region, ::Vec3 const& pos) /*override*/;


    // vIndex: 119

    virtual void potionSplash(::Vec3 const& pos, ::mce::Color const& color, bool instantaneousEffect) /*override*/;


    // vIndex: 120

    virtual bool extinguishFire(::BlockSource& region, ::BlockPos const& pos, uchar face, ::Actor* source) /*override*/;


    // vIndex: 122

    virtual ::std::unique_ptr<::Path>

    findPath(::Actor& from, int xBest, int yBest, int zBest, ::NavigationComponent& navigation) /*override*/;


    // vIndex: 121

    virtual ::std::unique_ptr<::Path>

    findPath(::Actor& from, ::Actor const& to, ::NavigationComponent& navigation) /*override*/;


    // vIndex: 124

    virtual void setSleepStatus(::PlayerSleepStatus const& status) /*override*/;


    // vIndex: 125

    virtual ::PlayerSleepStatus getSleepStatus() const /*override*/;


    // vIndex: 123

    virtual void updateSleepingPlayerList() /*override*/;


    // vIndex: 392

    virtual ::PlayerSleepManager const& getPlayerSleepManager() const = 0;


    // vIndex: 391

    virtual ::PlayerSleepManager& getPlayerSleepManager() = 0;


    // vIndex: 159

    virtual ::Bedrock::NonOwnerPointer<::ServerPlayerSleepManager> getServerPlayerSleepManager() /*override*/;


    // vIndex: 158

    virtual ::Bedrock::NonOwnerPointer<::ServerPlayerSleepManager const> getServerPlayerSleepManager() const

        /*override*/;


    // vIndex: 126

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


    // vIndex: 127

    virtual void setTime(int time) /*override*/;


    // vIndex: 128

    virtual uint getSeed() /*override*/;


    // vIndex: 129

    virtual ::LevelSeed64 getLevelSeed64() const /*override*/;


    // vIndex: 130

    virtual ::BlockPos const& getSharedSpawnPos() const /*override*/;


    // vIndex: 131

    virtual void setDefaultSpawn(::BlockPos const& spawnPos) /*override*/;


    // vIndex: 132

    virtual ::BlockPos const& getDefaultSpawn() const /*override*/;


    // vIndex: 133

    virtual void setDefaultGameType(::GameType gameType) /*override*/;


    // vIndex: 134

    virtual ::GameType getDefaultGameType() const /*override*/;


    // vIndex: 135

    virtual void setDifficulty(::SharedTypes::Legacy::Difficulty difficulty) /*override*/;


    // vIndex: 136

    virtual void setMultiplayerGameIntent(bool multiplayerGame) /*override*/;


    // vIndex: 137

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


    // vIndex: 138

    virtual void setMultiplayerGame(bool multiplayerGame) /*override*/;


    // vIndex: 139

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


    // vIndex: 140

    virtual void setLANBroadcastIntent(bool broadcast) /*override*/;


    // vIndex: 141

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


    // vIndex: 142

    virtual void setLANBroadcast(bool broadcast) /*override*/;


    // vIndex: 143

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


    // vIndex: 144

    virtual void setXBLBroadcastIntent(::Social::GamePublishSetting) /*override*/;


    // vIndex: 145

    virtual ::Social::GamePublishSetting getXBLBroadcastIntent() const /*override*/;


    // vIndex: 146

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


    // vIndex: 147

    virtual void setXBLBroadcastMode(::Social::GamePublishSetting) /*override*/;


    // vIndex: 148

    virtual ::Social::GamePublishSetting getXBLBroadcastMode() const /*override*/;


    // vIndex: 149

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


    // vIndex: 150

    virtual void setPlatformBroadcastIntent(::Social::GamePublishSetting) /*override*/;


    // vIndex: 151

    virtual ::Social::GamePublishSetting getPlatformBroadcastIntent() const /*override*/;


    // vIndex: 152

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


    // vIndex: 153

    virtual void setPlatformBroadcastMode(::Social::GamePublishSetting) /*override*/;


    // vIndex: 154

    virtual ::Social::GamePublishSetting getPlatformBroadcastMode() const /*override*/;


    // vIndex: 155

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


    // vIndex: 156

    virtual void setHasLockedBehaviorPack(bool hasLocked) /*override*/;


    // vIndex: 157

    virtual void setHasLockedResourcePack(bool hasLocked) /*override*/;


    // vIndex: 160

    virtual void setCommandsEnabled(bool commandsEnabled) /*override*/;


    // vIndex: 161

    virtual void setWorldTemplateOptionsUnlocked() /*override*/;


    // vIndex: 162

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


    // vIndex: 164

    virtual ::LevelStorage& getLevelStorage() /*override*/;


    // vIndex: 163

    virtual ::LevelStorage const& getLevelStorage() const /*override*/;


    // vIndex: 166

    virtual ::LevelData& getLevelData() /*override*/;


    // vIndex: 165

    virtual ::LevelData const& getLevelData() const /*override*/;


    // vIndex: 167

    virtual ::PhotoStorage& getPhotoStorage() const /*override*/;


    // vIndex: 168

    virtual void createPhotoStorage() /*override*/;


    // vIndex: 170

    virtual ::Bedrock::NotNullNonOwnerPtr<::PhotoManager> getPhotoManager() /*override*/;


    // vIndex: 169

    virtual ::Bedrock::NotNullNonOwnerPtr<::PhotoManager const> getPhotoManager() const /*override*/;


    // vIndex: 172

    virtual ::Bedrock::NotNullNonOwnerPtr<::EducationSettingsManager> getEducationSettingsManager() /*override*/;


    // vIndex: 171

    virtual ::Bedrock::NotNullNonOwnerPtr<::EducationSettingsManager const> getEducationSettingsManager() const

        /*override*/;


    // vIndex: 173

    virtual void save() /*override*/;


    // vIndex: 174

    virtual void saveLevelData() /*override*/;


    // vIndex: 175

    virtual void saveGameData() /*override*/;


    // vIndex: 176

    virtual ::std::shared_ptr<void*> requestTimedStorageDeferment() /*override*/;


    // vIndex: 177

    virtual ::TickingAreasManager& getTickingAreasMgr() /*override*/;


    // vIndex: 178

    virtual void addTickingAreaList(

        ::DimensionType                             dimensionId,

        ::std::shared_ptr<::TickingAreaList> const& tickingAreas

    ) /*override*/;


    // vIndex: 184

    virtual void playSound(

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    ) /*override*/;


    // vIndex: 183

    virtual void playSound(

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        float const                            volume,

        float const                            pitch

    ) /*override*/;


    // vIndex: 182

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


    // vIndex: 181

    virtual void playSound(

        ::IConstBlockSource const&             region,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    ) /*override*/;


    // vIndex: 180

    virtual void playSound(

        ::DimensionType                        dimension,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    ) /*override*/;


    // vIndex: 185

    virtual ::PlayerEventCoordinator& getRemotePlayerEventCoordinator() /*override*/;


    // vIndex: 186

    virtual ::ServerPlayerEventCoordinator& getServerPlayerEventCoordinator() /*override*/;


    // vIndex: 187

    virtual ::ClientPlayerEventCoordinator& getClientPlayerEventCoordinator() /*override*/;


    // vIndex: 188

    virtual ::ActorEventCoordinator& getActorEventCoordinator() /*override*/;


    // vIndex: 189

    virtual ::BlockEventCoordinator& getBlockEventCoordinator() /*override*/;


    // vIndex: 190

    virtual ::ItemEventCoordinator& getItemEventCoordinator() /*override*/;


    // vIndex: 191

    virtual ::ServerNetworkEventCoordinator& getServerNetworkEventCoordinator() /*override*/;


    // vIndex: 192

    virtual ::ScriptingEventCoordinator& getScriptingEventCoordinator() /*override*/;


    // vIndex: 193

    virtual ::ScriptDeferredEventCoordinator& getScriptDeferredEventCoordinator() /*override*/;


    // vIndex: 194

    virtual ::LevelEventCoordinator& getLevelEventCoordinator() /*override*/;


    // vIndex: 196

    virtual void handleLevelEvent(::SharedTypes::Legacy::LevelEvent type, ::Vec3 const& pos, int data) /*override*/;


    // vIndex: 195

    virtual void handleLevelEvent(::SharedTypes::Legacy::LevelEvent type, ::CompoundTag const& data) /*override*/;


    // vIndex: 197

    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelEventManager> getLevelEventManager() /*override*/;


    // vIndex: 198

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


    // vIndex: 199

    virtual void handleStopAllSounds() /*override*/;


    // vIndex: 200

    virtual void handleStopMusicEvent() /*override*/;


    // vIndex: 202

    virtual void broadcastLevelEvent(

        ::SharedTypes::Legacy::LevelEvent      type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::UserEntityIdentifierComponent const* userIdentifier

    ) /*override*/;


    // vIndex: 201

    virtual void broadcastLevelEvent(

        ::SharedTypes::Legacy::LevelEvent      type,

        ::CompoundTag const&                   tag,

        ::UserEntityIdentifierComponent const* userIdentifier

    ) /*override*/;


    // vIndex: 204

    virtual void broadcastLocalEvent(

        ::BlockSource&                    region,

        ::SharedTypes::Legacy::LevelEvent type,

        ::Vec3 const&                     pos,

        int                               data

    ) /*override*/;


    // vIndex: 203

    virtual void broadcastLocalEvent(

        ::BlockSource&                    region,

        ::SharedTypes::Legacy::LevelEvent type,

        ::Vec3 const&                     pos,

        ::Block const&                    block

    ) /*override*/;


    // vIndex: 207

    virtual void broadcastSoundEvent(

        ::BlockSource&                         region,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        ::Block const&                         block,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    ) /*override*/;


    // vIndex: 206

    virtual void broadcastSoundEvent(

        ::BlockSource&                         region,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    ) /*override*/;


    // vIndex: 205

    virtual void broadcastSoundEvent(

        ::Dimension&                           dimension,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    ) /*override*/;


    // vIndex: 208

    virtual void broadcastActorEvent(::Actor& actor, ::ActorEvent eventId, int data) const /*override*/;


    // vIndex: 209

    virtual ::Bedrock::NonOwnerPointer<::ActorEventBroadcaster const> getActorEventBroadcaster() const /*override*/;


    // vIndex: 210

    virtual void addChunkViewTracker(::std::weak_ptr<::ChunkViewSource> chunkViewSource) /*override*/;


    // vIndex: 211

    virtual void onChunkReload(::Bounds const& bound) /*override*/;


    // vIndex: 213

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


    // vIndex: 214

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


    // vIndex: 216

    virtual void forEachPlayer(::std::function<bool(::Player&)> callback) /*override*/;


    // vIndex: 215

    virtual void forEachPlayer(::std::function<bool(::Player const&)> callback) const /*override*/;


    // vIndex: 218

    virtual void forEachUser(::std::function<bool(::EntityContext&)> callback) /*override*/;


    // vIndex: 217

    virtual void forEachUser(::std::function<bool(::EntityContext const&)> callback) const /*override*/;


    // vIndex: 220

    virtual ::Player* findPlayer(::std::function<bool(::Player const&)> pred) const /*override*/;


    // vIndex: 219

    virtual ::Player* findPlayer(::std::function<bool(::WeakEntityRef const&)> pred) const /*override*/;


    // vIndex: 221

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


    // vIndex: 222

    virtual int countUsersWithMatchingNetworkId(::NetworkIdentifier const& networkId) const /*override*/;


    // vIndex: 223

    virtual ::std::vector<::OwnerPtr<::EntityContext>> const& getUsers() const /*override*/;


    // vIndex: 224

    virtual ::std::vector<::OwnerPtr<::EntityContext>> const& getEntities() const /*override*/;


    // vIndex: 1

    virtual void onSourceCreated(::BlockSource& source) /*override*/;


    // vIndex: 2

    virtual void onSourceDestroyed(::BlockSource& source) /*override*/;


    // vIndex: 225

    virtual void onSubChunkLoaded(

        ::ChunkSource& source,

        ::LevelChunk&  lc,

        short          absoluteSubChunkIndex,

        bool           subChunkVisibilityChanged

    ) /*override*/;


    // vIndex: 226

    virtual ::Bedrock::NonOwnerPointer<::SubChunkManager> getSubChunkManager() /*override*/;


    // vIndex: 227

    virtual void onChunkLoaded(::ChunkSource& source, ::LevelChunk& lc) /*override*/;


    // vIndex: 212

    virtual void onChunkReloaded(::ChunkSource& source, ::LevelChunk& lc) /*override*/;


    // vIndex: 230

    virtual ::LevelChunkMetaDataManager* getLevelChunkMetaDataManager() /*override*/;


    // vIndex: 228

    virtual void onChunkDiscarded(::LevelChunk& lc) /*override*/;


    // vIndex: 229

    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelChunkEventManager> getLevelChunkEventManager() /*override*/;


    // vIndex: 231

    virtual void queueEntityDestruction(::OwnerPtr<::EntityContext> entity) /*override*/;


    // vIndex: 233

    virtual ::OwnerPtr<::EntityContext> removeEntity(::Actor& actor) /*override*/;


    // vIndex: 232

    virtual ::OwnerPtr<::EntityContext> removeEntity(::WeakEntityRef entityRef) /*override*/;


    // vIndex: 234

    virtual void forceRemoveEntity(::Actor& actor) /*override*/;


    // vIndex: 235

    virtual void forceRemoveEntityfromWorld(::Actor& actor) /*override*/;


    // vIndex: 236

    virtual void forceFlushRemovedPlayers() /*override*/;


    // vIndex: 237

    virtual void loadFunctionManager() /*override*/;


    // vIndex: 238

    virtual void levelCleanupQueueEntityRemoval(::OwnerPtr<::EntityContext> entity) /*override*/;


    // vIndex: 239

    virtual void registerTemporaryPointer(::_TickPtr& ptr) /*override*/;


    // vIndex: 240

    virtual void unregisterTemporaryPointer(::_TickPtr& ptr) /*override*/;


    // vIndex: 241

    virtual ::Bedrock::NotNullNonOwnerPtr<::TempEPtrManager> getTempEPtrManager() /*override*/;


    // vIndex: 242

    virtual bool destroyBlock(

        ::BlockSource&              region,

        ::BlockPos const&           pos,

        bool                        dropResources,

        ::BlockChangeContext const& changeSourceContext

    ) /*override*/;


    // vIndex: 243

    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelBlockDestroyer> getLevelBlockDestroyer() /*override*/;


    // vIndex: 244

    virtual void upgradeStorageVersion(::StorageVersion v) /*override*/;


    // vIndex: 245

    virtual void suspendAndSave() /*override*/;


    // vIndex: 179

    virtual void

    sendServerLegacyParticle(::ParticleType id, ::Vec3 const& pos, ::Vec3 const& dir, int data) /*override*/;


    // vIndex: 246

    virtual ::Particle* addParticle(

        ::ParticleType       id,

        ::Vec3 const&        pos,

        ::Vec3 const&        dir,

        int                  data,

        ::CompoundTag const* tag,

        bool                 isGlobal

    ) /*override*/;


    // vIndex: 116

    virtual void spawnParticleEffect(

        ::std::string const& effectName,

        ::Vec3 const&        spawnLocation,

        ::Dimension*         dimension

    ) /*override*/;


    // vIndex: 117

    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerParticleManager> getServerParticleManager() /*override*/;


    // vIndex: 247

    virtual void addParticleEffect(

        ::HashedString const&      effect,

        ::Vec3 const&              emitterPosition,

        ::MolangVariableMap const& molangVariables

    ) /*override*/;


    // vIndex: 248

    virtual void addTerrainParticleEffect(

        ::BlockPos const& pos,

        ::Block const&    block,

        ::Vec3 const&     emitterPosition,

        float             intensity,

        float             velocityScalar,

        float             emitterRadius

    ) /*override*/;


    // vIndex: 249

    virtual void addTerrainSlideEffect(

        ::BlockPos const& pos,

        ::Block const&    block,

        ::Vec3 const&     emitterPosition,

        float             intensity,

        float             velocityScalar,

        float             emitterRadius

    ) /*override*/;


    // vIndex: 250

    virtual void addBreakingItemParticleEffect(

        ::Vec3 const&                     pos,

        ::BreakingItemParticleData const& data,

        ::ResolvedItemIconInfo const&     textureInfo

    ) /*override*/;


    // vIndex: 251

    virtual void addBiomeTintedParticleEffect(

        ::HashedString const&         effect,

        ::BlockPos const&             pos,

        ::Block const&                block,

        ::std::optional<::mce::Color> overrideColor

    ) /*override*/;


    // vIndex: 252

    virtual ::ActorUniqueID getNewUniqueID() /*override*/;


    // vIndex: 253

    virtual ::ActorRuntimeID getNextRuntimeID() /*override*/;


    // vIndex: 254

    virtual ::std::vector<::ChunkPos> const& getTickingOffsets() const /*override*/;


    // vIndex: 255

    virtual ::std::vector<::ChunkPos> const& getClientTickingOffsets() const /*override*/;


    // vIndex: 256

    virtual ::std::vector<::ChunkPos>

    getSortedPositionsFromClientOffsets(::std::vector<::ChunkPos> const& centers) const /*override*/;


    // vIndex: 257

    virtual ::Bedrock::NotNullNonOwnerPtr<::ChunkTickOffsetManager const> getChunkTickOffsetManager() const

        /*override*/;


    // vIndex: 258

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


    // vIndex: 259

    virtual void setIsExporting(bool IsExporting) /*override*/;


    // vIndex: 260

    virtual ::SavedDataStorage& getSavedData() /*override*/;


    // vIndex: 263

    virtual ::MapItemSavedData* getMapSavedData(::ActorUniqueID const uuid) /*override*/;


    // vIndex: 262

    virtual ::MapItemSavedData* getMapSavedData(::CompoundTag const& instance) /*override*/;


    // vIndex: 261

    virtual ::MapItemSavedData* getMapSavedData(::CompoundTag const* instance) /*override*/;


    // vIndex: 264

    virtual void requestMapInfo(::ActorUniqueID const uuid, bool forceUpdate) /*override*/;


    // vIndex: 265

    virtual ::ActorUniqueID expandMapByID(::ActorUniqueID const uuid, bool wasInit) /*override*/;


    // vIndex: 266

    virtual bool copyAndLockMap(::ActorUniqueID const originalMapUuid, ::ActorUniqueID const newMapUuid) /*override*/;


    // vIndex: 268

    virtual ::MapItemSavedData& createMapSavedData(

        ::ActorUniqueID const& uuid,

        ::BlockPos const&      origin,

        ::DimensionType        dimension,

        int                    returnScaleLevel

    ) /*override*/;


    // vIndex: 267

    virtual ::MapItemSavedData& createMapSavedData(

        ::std::vector<::ActorUniqueID> const& mapIds,

        ::BlockPos const&                     origin,

        ::DimensionType                       dimension,

        int                                   returnScaleLevel

    ) /*override*/;


    // vIndex: 269

    virtual ::Core::PathBuffer<::std::string> getScreenshotsFolder() const /*override*/;


    // vIndex: 270

    virtual ::std::string getLevelId() const /*override*/;


    // vIndex: 271

    virtual void setLevelId(::std::string LevelId) /*override*/;


    // vIndex: 272

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


    // vIndex: 273

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


    // vIndex: 274

    virtual ::ResourcePackManager* getClientResourcePackManager() const /*override*/;


    // vIndex: 275

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


    // vIndex: 276

    virtual ::TradeTables* getTradeTables() /*override*/;


    // vIndex: 277

    virtual void decrementTagCache(

        ::std::string const&                                                      tag,

        ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& tagRegistry

    ) /*override*/;


    // vIndex: 278

    virtual void incrementTagCache(

        ::std::string const&                                                      tag,

        ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& tagRegistry

    ) /*override*/;


    // vIndex: 279

    virtual ::Bedrock::NonOwnerPointer<::TagCacheManager> getTagCacheManager() /*override*/;


    // vIndex: 280

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


    // vIndex: 282

    virtual ::ActorFactory& getActorFactory() /*override*/;


    // vIndex: 281

    virtual ::ActorFactory const& getActorFactory() const /*override*/;


    // vIndex: 283

    virtual ::ActorInfoRegistry* getActorInfoRegistry() /*override*/;


    // vIndex: 285

    virtual ::StackRefResult<::EntityRegistry> getEntityRegistry() /*override*/;


    // vIndex: 284

    virtual ::StackRefResult<::EntityRegistry const> getEntityRegistry() const /*override*/;


    // vIndex: 286

    virtual ::EntitySystems& getEntitySystems() /*override*/;


    // vIndex: 288

    virtual ::WeakRef<::EntityContext> getLevelEntity() /*override*/;


    // vIndex: 287

    virtual ::WeakRef<::EntityContext const> getLevelEntity() const /*override*/;


    // vIndex: 289

    virtual ::Bedrock::NonOwnerPointer<::VolumeEntityManagerServer> tryGetVolumeEntityManagerServer() const

        /*override*/;


    // vIndex: 291

    virtual void runCommand(

        ::HashedString const&     commandStr,

        ::CommandOrigin&          origin,

        ::CommandOriginSystem     originSystem,

        ::CurrentCmdVersion const commandVersion

    ) /*override*/;


    // vIndex: 290

    virtual void

    runCommand(::Command& command, ::CommandOrigin& origin, ::CommandOriginSystem originSystem) /*override*/;


    // vIndex: 292

    virtual ::PlayerCapabilities::ISharedController const& getCapabilities() const /*override*/;


    // vIndex: 293

    virtual ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& getTagRegistry() /*override*/;


    // vIndex: 294

    virtual ::PlayerMovementSettings const& getPlayerMovementSettings() const /*override*/;


    // vIndex: 295

    virtual void setPlayerMovementSettings(::PlayerMovementSettings const& settings) /*override*/;


    // vIndex: 297

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerMovementSettingsManager>

    getPlayerMovementSettingsManager() /*override*/;


    // vIndex: 296

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerMovementSettingsManager const>

    getPlayerMovementSettingsManager() const /*override*/;


    // vIndex: 298

    virtual ::TickDeathSettings const& getTickDeathSettings() const /*override*/;


    // vIndex: 299

    virtual void setTickDeathSettings(::TickDeathSettings const& settings) /*override*/;


    // vIndex: 300

    virtual bool canUseSkin(

        ::SerializedSkin const&    skin,

        ::NetworkIdentifier const& networkIdentifier,

        ::ActorUniqueID const&     playerId

    ) const /*override*/;


    // vIndex: 301

    virtual ::Bedrock::NonOwnerPointer<::TrustedSkinHelper const> getTrustedSkinHelper() const /*override*/;


    // vIndex: 375

    virtual ::Bedrock::NonOwnerPointer<::CameraRegistry const> getCameraRegistry() const /*override*/;


    // vIndex: 374

    virtual ::Bedrock::NonOwnerPointer<::CameraRegistry> getCameraRegistry() /*override*/;


    // vIndex: 376

    virtual ::Bedrock::NonOwnerPointer<::EntitySystems> getCameraSystems() /*override*/;


    // vIndex: 302

    virtual ::PositionTrackingDB::PositionTrackingDBClient* getPositionTrackerDBClient() const /*override*/;


    // vIndex: 303

    virtual ::PositionTrackingDB::PositionTrackingDBServer* getPositionTrackerDBServer() const /*override*/;


    // vIndex: 304

    virtual void flushRunTimeLighting() /*override*/;


    // vIndex: 305

    virtual void loadBlockDefinitionGroup(::Experiments const& experiments) /*override*/;


    // vIndex: 306

    virtual void initializeBlockDefinitionGroup() /*override*/;


    // vIndex: 307

    virtual ::Bedrock::NonOwnerPointer<::IUnknownBlockTypeRegistry> getUnknownBlockTypeRegistry() /*override*/;


    // vIndex: 377

    virtual bool isClientSideGenerationEnabled() /*override*/;


    // vIndex: 378

    virtual bool blockNetworkIdsAreHashes() /*override*/;


    // vIndex: 379

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


    // vIndex: 380

    virtual ::Bedrock::NotNullNonOwnerPtr<::BlockTypeRegistry> getBlockTypeRegistry() const /*override*/;


    // vIndex: 372

    virtual ::Level* asLevel() /*override*/;


    // vIndex: 368

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


    // vIndex: 381

    virtual void pauseAndFlushTaskGroups() /*override*/;


    // vIndex: 10

    virtual ::DimensionManager& getDimensionManager() /*override*/;


    // vIndex: 9

    virtual ::DimensionManager const& getDimensionManager() const /*override*/;


    // vIndex: 384

    virtual void subChunkTickAndSendRequests() /*override*/;


    // vIndex: 393

    virtual void _subTick();


    // vIndex: 111

    virtual ::StackRefResult<::PauseManager> getPauseManager() /*override*/;


    // vIndex: 110

    virtual ::StackRefResult<::PauseManager const> getPauseManager() const /*override*/;


    // vIndex: 308

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


    // vIndex: 309

    virtual ::std::unordered_map<::mce::UUID, ::PlayerListEntry> const& getPlayerList() const /*override*/;


    // vIndex: 310

    virtual ::std::string const& getPlayerXUID(::mce::UUID const& uuid) const /*override*/;


    // vIndex: 311

    virtual ::std::string const& getPlayerPlatformOnlineId(::mce::UUID const& uuid) const /*override*/;


    // vIndex: 313

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerListManager> getPlayerListManager() /*override*/;


    // vIndex: 312

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerListManager const> getPlayerListManager() const /*override*/;


    // vIndex: 314

    virtual ::std::vector<::WeakEntityRef> const& getActiveUsers() const /*override*/;


    // vIndex: 316

    virtual void notifySubChunkRequestManager(::SubChunkPacket const& packet) /*override*/;


    // vIndex: 317

    virtual ::SubChunkRequestManager* getSubChunkRequestManager() /*override*/;


    // vIndex: 315

    virtual ::std::vector<::Actor*> getRuntimeActorList() const /*override*/;


    // vIndex: 318

    virtual ::PacketSender* getPacketSender() const /*override*/;


    // vIndex: 319

    virtual ::Bedrock::NonOwnerPointer<::NetEventCallback> getNetEventCallback() const /*override*/;


    // vIndex: 320

    virtual void setNetEventCallback(::Bedrock::NonOwnerPointer<::NetEventCallback> val) /*override*/;


    // vIndex: 321

    virtual ::gsl::not_null<::StackRefResult<::ILevelRandom>> getILevelRandom() /*override*/;


    // vIndex: 322

    virtual ::IRandom& getIRandom() const /*override*/;


    // vIndex: 323

    virtual ::Random& getRandom() const /*override*/;


    // vIndex: 324

    virtual ::Random& getThreadRandom() const /*override*/;


    // vIndex: 325

    virtual ::HitResult& getHitResult() /*override*/;


    // vIndex: 326

    virtual ::HitResult& getLiquidHitResult() /*override*/;


    // vIndex: 327

    virtual ::Bedrock::NotNullNonOwnerPtr<::HitResultWrapper> getHitResultWrapper() /*override*/;


    // vIndex: 328

    virtual ::std::string const& getImmersiveReaderString() const /*override*/;


    // vIndex: 329

    virtual void setImmersiveReaderString(::std::string newString) /*override*/;


    // vIndex: 331

    virtual ::AdventureSettings& getAdventureSettings() /*override*/;


    // vIndex: 330

    virtual ::AdventureSettings const& getAdventureSettings() const /*override*/;


    // vIndex: 333

    virtual ::GameRules const& getGameRules() const /*override*/;


    // vIndex: 332

    virtual ::GameRules& getGameRules() /*override*/;


    // vIndex: 334

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


    // vIndex: 335

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


    // vIndex: 336

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


    // vIndex: 337

    virtual ::Abilities& getDefaultAbilities() /*override*/;


    // vIndex: 339

    virtual ::PermissionsHandler& getDefaultPermissions() /*override*/;


    // vIndex: 338

    virtual ::PermissionsHandler const& getDefaultPermissions() const /*override*/;


    // vIndex: 340

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


    // vIndex: 341

    virtual void takePicture(

        ::cg::ImageBuffer&                                              outImage,

        ::Actor*                                                        camera,

        ::Actor*                                                        target,

        ::ScreenshotOptions&                                            screenshotOptions,

        ::std::function<void(::cg::ImageBuffer&, ::ScreenshotOptions&)> completedScreenshotCallback

    ) /*override*/;


    // vIndex: 342

    virtual ::LevelSoundManager& getLevelSoundManager() /*override*/;


    // vIndex: 343

    virtual ::Bedrock::NotNullNonOwnerPtr<::SoundPlayerInterface> getSoundPlayer() const /*override*/;


    // vIndex: 344

    virtual void setSimPaused(bool value) /*override*/;


    // vIndex: 345

    virtual bool getSimPaused() /*override*/;


    // vIndex: 346

    virtual void setFinishedInitializing() /*override*/;


    // vIndex: 347

    virtual ::LootTables& getLootTables() /*override*/;


    // vIndex: 348

    virtual void updateWeather(float rainLevel, int rainTime, float lightningLevel, int lightningTime) /*override*/;


    // vIndex: 349

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


    // vIndex: 351

    virtual ::Scoreboard& getScoreboard() /*override*/;


    // vIndex: 350

    virtual ::Scoreboard const& getScoreboard() const /*override*/;


    // vIndex: 352

    virtual ::Scoreboard* tryGetScoreboard() /*override*/;


    // vIndex: 353

    virtual ::LayeredAbilities* getPlayerAbilities(::ActorUniqueID const& playerId) /*override*/;


    // vIndex: 354

    virtual void setPlayerAbilities(::ActorUniqueID const& playerId, ::LayeredAbilities const& abilities) /*override*/;


    // vIndex: 355

    virtual void sendAllPlayerAbilities(::Player const& playerReference) /*override*/;


    // vIndex: 356

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerAbilitiesManager> getPlayerAbilitiesManager() /*override*/;


    // vIndex: 357

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerPermissionsManager> getPlayerPermissionsManager() /*override*/;


    // vIndex: 358

    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerPermissionsSynchroniser>

    getPlayerPermissionsSynchroniser() /*override*/;


    // vIndex: 360

    virtual ::Recipes& getRecipes() const /*override*/;


    // vIndex: 361

    virtual ::BlockReducer* getBlockReducer() const /*override*/;


    // vIndex: 363

    virtual ::std::weak_ptr<::TrimPatternRegistry const> getTrimPatternRegistry() const /*override*/;


    // vIndex: 362

    virtual ::std::weak_ptr<::TrimPatternRegistry> getTrimPatternRegistry() /*override*/;


    // vIndex: 365

    virtual ::std::weak_ptr<::TrimMaterialRegistry const> getTrimMaterialRegistry() const /*override*/;


    // vIndex: 364

    virtual ::std::weak_ptr<::TrimMaterialRegistry> getTrimMaterialRegistry() /*override*/;


    // vIndex: 366

    virtual ::BlockType const& getRegisteredBorderBlock() const /*override*/;


    // vIndex: 367

    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelChunkPerformanceTelemetry>

    getLevelChunkPerformanceTelemetry() /*override*/;


    // vIndex: 383

    virtual ::cereal::ReflectionCtx& cerealContext() /*override*/;


    // vIndex: 382

    virtual ::cereal::ReflectionCtx const& cerealContext() const /*override*/;


    // vIndex: 370

    virtual ::Bedrock::NonOwnerPointer<::ChunkGenerationManager> getChunkGenerationManager() /*override*/;


    // vIndex: 369

    virtual ::Bedrock::NonOwnerPointer<::ChunkGenerationManager const> getChunkGenerationManager() const /*override*/;


    // vIndex: 385

    virtual void digestServerBlockProperties(::StartGamePacket const& packet) /*override*/;


    // vIndex: 359

    virtual ::MolangPackSettingsCache* getMolangPackSettingsCache() /*override*/;


    // vIndex: 386

    virtual ::PlayerDeathManager* _getPlayerDeathManager() /*override*/;


    // vIndex: 394

    virtual void _initializeMapDataManager();


    // vIndex: 388

    virtual ::cereal::ReflectionCtx& _cerealContext() /*override*/;


    // vIndex: 389

    virtual void _onLowMemory() /*override*/;

    // NOLINTEND


public:

    // member functions

    // NOLINTBEGIN

    MCAPI Level(

        ::Bedrock::NotNullNonOwnerPtr<::PacketSender>                packetSender,

        ::Bedrock::NotNullNonOwnerPtr<::SoundPlayerInterface> const& soundPlayer,

        ::Bedrock::UniqueOwnerPointer<::LevelStorage>                levelStorage,

        ::Bedrock::NotNullNonOwnerPtr<::LevelData>                   levelData,

        ::IMinecraftEventing&                                        eventing,

        bool                                                         isClientSide,

        ::SubClientId                                                subClientId,

        ::Scheduler&                                                 callbackContext,

        ::Bedrock::NotNullNonOwnerPtr<::StructureManager>            structureManager,

        ::ResourcePackManager&                                       addOnResourcePackManager,

        ::Bedrock::NotNullNonOwnerPtr<::IEntityRegistryOwner> const& entityRegistryOwner,

        ::WeakRef<::EntityContext>                                   levelEntity,

        ::ItemRegistryRef                                            itemRegistry,

        ::Bedrock::NotNullNonOwnerPtr<::BlockTypeRegistry>           blockTypeRegistry,

        bool                                                         clientSideChunkGenerationEnabled,

        bool                                                         blockNetworkIdsAreHashes,

        ::NetworkPermissions const&                                  networkPermissions,

        ::std::optional<::DimensionDefinitionGroup>                  dimensionDefinitionGroup,

        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator>           validator,

        ::std::unique_ptr<::ParticleProvider>                        particles

    );


    MCAPI ::Bedrock::UniqueOwnerPointer<::PhotoManager> _createPhotoManager();


    MCAPI void _initializeActorManager();


    MCAPI void _initializeBiomeManager();


    MCAPI void _initializeEventCoordinatorManager();


    MCAPI void _initializeGameplayUserManager();


    MCAPI void _initializeLevelChunkEventManager();


    MCAPI void _initializeLevelEventManager();


    MCAPI void _initializeParticleProvider();


    MCAPI void _onAddBiomeTintedParticleEffect(

        ::HashedString const&         effect,

        ::BlockPos const&             pos,

        ::Block const&                block,

        ::std::optional<::mce::Color> overrideColor

    );


    MCAPI void _onAddBreakingItemParticleEffect(

        ::Vec3 const&                     pos,

        ::BreakingItemParticleData const& data,

        ::ResolvedItemIconInfo const&     textureInfo

    );


    MCAPI void _onAddTerrainParticleEffect(

        ::BlockPos const& pos,

        ::Block const&    block,

        ::Vec3 const&     emitterPosition,

        float             particleCount,

        float             velocityScalar,

        float             emitterRadius

    );


    MCAPI void _onAddTerrainSlideEffect(

        ::BlockPos const& pos,

        ::Block const&    block,

        ::Vec3 const&     emitterPosition,

        float             particleCount,

        float             velocityScalar,

        float             emitterRadius

    );


    MCAPI void _onAnyGameplayUsersRemoved();


    MCAPI void _onChunkDiscarded(::LevelChunk& levelChunk);


    MCAPI void _onChunkLoaded(::ChunkSource& chunkSource, ::LevelChunk& levelChunk, int);


    MCAPI void _onChunkReloaded(::ChunkSource& chunkSource, ::LevelChunk& levelChunk);


    MCAPI void _onGameplayUserAdded(::EntityContext& entity);


    MCAPI void _onGameplayUserRemoved(::EntityContext& entity);


    MCAPI void _onLevelEventCompoundTag(::SharedTypes::Legacy::LevelEvent type, ::CompoundTag const& data);


    MCAPI void _onLevelEventData(::SharedTypes::Legacy::LevelEvent type, ::Vec3 const& pos, int data);


    MCAPI void _onPictureTaken(

        ::cg::ImageBuffer&                                              outImage,

        ::Actor*                                                        camera,

        ::Actor*                                                        target,

        ::ScreenshotOptions&                                            screenshotOptions,

        ::std::function<void(::cg::ImageBuffer&, ::ScreenshotOptions&)> completedScreenshotCallback

    );


    MCAPI void _onRemoveActorEntityReferences(::Actor& actor);


    MCAPI void _onSendServerLegacyParticle(::ParticleType id, ::Vec3 const& pos, ::Vec3 const& dir, int data);


    MCAPI ::Bedrock::Result<::Actor*, ::ActorValidationError>

    addEntityWithError(::BlockSource& region, ::OwnerPtr<::EntityContext> entity);


    MCAPI void earlyShutdownMainthread();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorManager> getActorManager();


    MCAPI ::ServerLevelEventCoordinator& getServerLevelEventCoordinator();


    MCAPI void setShapeRegistry(::std::shared_ptr<::VoxelShapes::VoxelShapeRegistry> registry);

    // NOLINTEND


public:

    // static functions

    // NOLINTBEGIN

    MCAPI static ::std::unique_ptr<::LevelStorageManager> _createLevelStorageManager(

        ::Bedrock::UniqueOwnerPointer<::LevelStorage> levelStorage,

        ::Scheduler&                                  scheduler,

        ::IMinecraftEventing&                         eventing

    );


    MCAPI static ::std::unique_ptr<::PlayerLimboActorManager> _createPlayerLimboActorManager(

        ::LevelStorageManager*                        levelStorageManager,

        ::Bedrock::NotNullNonOwnerPtr<::ActorManager> actorManager,

        ::Bedrock::NotNullNonOwnerPtr<::ActorFactory> actorFactory

    );

    // NOLINTEND


public:

    // constructor thunks

    // NOLINTBEGIN

    MCAPI void* $ctor(

        ::Bedrock::NotNullNonOwnerPtr<::PacketSender>                packetSender,

        ::Bedrock::NotNullNonOwnerPtr<::SoundPlayerInterface> const& soundPlayer,

        ::Bedrock::UniqueOwnerPointer<::LevelStorage>                levelStorage,

        ::Bedrock::NotNullNonOwnerPtr<::LevelData>                   levelData,

        ::IMinecraftEventing&                                        eventing,

        bool                                                         isClientSide,

        ::SubClientId                                                subClientId,

        ::Scheduler&                                                 callbackContext,

        ::Bedrock::NotNullNonOwnerPtr<::StructureManager>            structureManager,

        ::ResourcePackManager&                                       addOnResourcePackManager,

        ::Bedrock::NotNullNonOwnerPtr<::IEntityRegistryOwner> const& entityRegistryOwner,

        ::WeakRef<::EntityContext>                                   levelEntity,

        ::ItemRegistryRef                                            itemRegistry,

        ::Bedrock::NotNullNonOwnerPtr<::BlockTypeRegistry>           blockTypeRegistry,

        bool                                                         clientSideChunkGenerationEnabled,

        bool                                                         blockNetworkIdsAreHashes,

        ::NetworkPermissions const&                                  networkPermissions,

        ::std::optional<::DimensionDefinitionGroup>                  dimensionDefinitionGroup,

        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator>           validator,

        ::std::unique_ptr<::ParticleProvider>                        particles

    );

    // NOLINTEND


public:

    // destructor thunk

    // NOLINTBEGIN

    MCAPI void $dtor();

    // NOLINTEND


public:

    // virtual function thunks

    // NOLINTBEGIN

    MCAPI bool $initialize(

        ::std::string const&   levelName,

        ::LevelSettings const& levelSettings,

        ::Experiments const&   experiments,

        ::std::string const*   levelId,

        ::std::optional<::std::reference_wrapper<

            ::std::unordered_map<::std::string, ::std::unique_ptr<::BiomeJsonDocumentGlue::ResolvedBiomeData>>>>

            biomeIdToResolvedData

    );


    MCAPI void $startLeaveGame();


    MCAPI bool $isLeaveGameDone();


    MCAPI ::WeakRef<::Dimension> $getOrCreateDimension(::DimensionType dimensionType);


    MCAPI ::WeakRef<::Dimension> $getDimension(::DimensionType id) const;


    MCAPI ::DimensionType $getLastOrDefaultSpawnDimensionId(::DimensionType lastDimensionId) const;


    MCFOLD void $forEachDimension(::std::function<bool(::Dimension&)> callback);


    MCFOLD void $forEachDimension(::std::function<bool(::Dimension const&)> callback) const;


    MCAPI uint $getChunkTickRange() const;


    MCAPI ::ChunkTickRangeManager const& $getChunkTickRangeManager() const;


    MCAPI ::PortalForcer& $getPortalForcer();


    MCAPI void $requestPlayerChangeDimension(::Player& player, ::ChangeDimensionRequest&& changeRequest);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::PlayerDimensionTransferManager> $getPlayerDimensionTransferManager();


    MCAPI void $entityChangeDimension(::Actor& entity, ::DimensionType toId, ::std::optional<::Vec3> entityPos);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorDimensionTransferManager> $getActorDimensionTransferManager();


    MCFOLD ::Spawner& $getSpawner() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::BossEventSubscriptionManager> $getBossEventSubscriptionManager();


    MCFOLD ::ProjectileFactory& $getProjectileFactory() const;


    MCFOLD ::ActorDefinitionGroup* $getEntityDefinitions() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationGroup> $getActorAnimationGroup() const;


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


    MCAPI ::BlockDefinitionGroup* $getBlockDefinitions() const;


    MCFOLD ::PropertyGroupManager& $getActorPropertyGroup() const;


    MCFOLD ::CameraPresets const& $getCameraPresets() const;


    MCFOLD ::CameraPresets& $getCameraPresets();


    MCAPI ::SharedTypes::v1_21_90::CameraPreset const* $getCameraPreset(int presetIndex) const;


    MCAPI bool $getDisablePlayerInteractions() const;


    MCAPI void $setDisablePlayerInteractions(bool const disable);


    MCFOLD ::AutomationBehaviorTreeGroup& $getAutomationBehaviorTreeGroup() const;


    MCAPI ::BehaviorFactory& $getBehaviorFactory() const;


    MCAPI ::SharedTypes::Legacy::Difficulty $getDifficulty() const;


    MCAPI ::DimensionConversionData $getDimensionConversionData() const;


    MCAPI float $getSpecialMultiplier(::DimensionType dimensionType) const;


    MCAPI bool $hasCommandsEnabled() const;


    MCAPI bool $useMsaGamertagsOnly() const;


    MCAPI void $setMsaGamertagsOnly(bool msaGamertagsOnly);


    MCAPI ::Actor* $addEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity);


    MCAPI ::Actor* $putEntity(

        ::BlockSource&              region,

        ::ActorUniqueID             id,

        ::ActorRuntimeID            runtimeId,

        ::OwnerPtr<::EntityContext> entity

    );


    MCAPI ::Actor* $putEntity(::BlockSource& region, ::ActorUniqueID id, ::OwnerPtr<::EntityContext> entity);


    MCAPI ::Actor* $addGlobalEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity);


    MCAPI ::Actor* $addAutonomousEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity);


    MCAPI void $addUser(::OwnerPtr<::EntityContext> userEntity);


    MCAPI ::Actor* $addDisplayEntity(::BlockSource&, ::OwnerPtr<::EntityContext>);


    MCFOLD void $removeDisplayEntity(::WeakEntityRef);


    MCFOLD ::Bedrock::NonOwnerPointer<::DisplayActorManager> $getDisplayActorManager();


    MCAPI void $suspendPlayer(::Player& player);


    MCAPI void $resumePlayer(::Player& player);


    MCAPI bool $isPlayerSuspended(::Player& player) const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::GameplayUserManager> $getGameplayUserManager();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::GameplayUserManager const> $getGameplayUserManager() const;


    MCAPI ::Bedrock::NonOwnerPointer<::PlayerLocationReceiver> $getPlayerLocationReceiver();


    MCAPI ::OwnerPtr<::EntityContext> $removeActorAndTakeEntity(::WeakEntityRef entityRef);


    MCAPI ::OwnerPtr<::EntityContext> $removeActorFromWorldAndTakeEntity(::WeakEntityRef entityRef);


    MCAPI ::OwnerPtr<::EntityContext> $takeEntity(::WeakEntityRef entityRef, ::LevelChunk& lc);


    MCAPI ::StrictEntityContext $fetchStrictEntity(::ActorUniqueID actorId, bool getRemoved) const;


    MCAPI ::Actor* $fetchEntity(::ActorUniqueID actorId, bool getRemoved) const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorFetcher const> $getActorFetcher() const;


    MCAPI ::Actor* $getRuntimeEntity(::ActorRuntimeID actorId, bool getRemoved) const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ActorRuntimeIDManager> $getActorRuntimeIDManager();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ActorRuntimeIDManager const> $getActorRuntimeIDManager() const;


    MCAPI ::Mob* $getMob(::ActorUniqueID mobId) const;


    MCAPI ::Player* $getPlayer(::std::string const& name) const;


    MCAPI ::Player* $getPlayer(::mce::UUID const& uuid) const;


    MCAPI ::Player* $getPlayer(::ActorUniqueID entityID) const;


    MCAPI ::Player* $getPlayerByXuid(::std::string const& xuid) const;


    MCAPI ::Player* $getPlatformPlayer(::std::string const& platformOnlineId) const;


    MCAPI ::Player* $getPlayerFromServerId(::std::string const& serverId) const;


    MCAPI ::Player* $getRuntimePlayer(::ActorRuntimeID runtimeId) const;


    MCAPI int $getNumRemotePlayers() const;


    MCAPI ::Player* $getPrimaryLocalPlayer() const;


    MCAPI ::IMinecraftEventing& $getEventing();


    MCAPI ::mce::Color $getPlayerColor(::Player const& player) const;


    MCAPI ::Tick const& $getCurrentTick() const;


    MCAPI ::Tick const $getCurrentServerTick() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TickDeltaTimeManager const> $getTickDeltaTimeManager() const;


    MCFOLD ::ArmorTrimUnloader* $getArmorTrimUnloader();


    MCAPI ::VoxelShapes::VoxelShapeRegistry const* $getShapeRegistry() const;


    MCFOLD ::BiomeRegistry const& $getBiomeRegistry() const;


    MCFOLD ::BiomeRegistry& $getBiomeRegistry();


    MCFOLD ::BlockPalette const& $getBlockPalette() const;


    MCFOLD ::BlockPalette& $getBlockPalette();


    MCFOLD ::FeatureRegistry const& $getFeatureRegistry() const;


    MCFOLD ::FeatureRegistry& $getFeatureRegistry();


    MCFOLD ::FeatureTypeFactory const& $getFeatureTypeFactory() const;


    MCFOLD ::FeatureTypeFactory& $getFeatureTypeFactory();


    MCFOLD ::JigsawStructureRegistry const& $getJigsawStructureRegistry() const;


    MCFOLD ::JigsawStructureRegistry& $getJigsawStructureRegistry();


    MCFOLD ::StructureSpawnRegistry const& $getStructureSpawnRegistry() const;


    MCFOLD ::StructureSpawnRegistry& $getStructureSpawnRegistry();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::StructureManager> const $getStructureManager() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::StructureManager> $getStructureManager();


    MCFOLD ::BiomeComponentFactory const& $getBiomeComponentFactory() const;


    MCFOLD ::BiomeComponentFactory& $getBiomeComponentFactory();


    MCFOLD ::SurfaceBuilderRegistry const& $getSurfaceBuilderRegistry() const;


    MCFOLD ::SurfaceBuilderRegistry& $getSurfaceBuilderRegistry();


    MCAPI ::BiomeManager const& $getBiomeManager() const;


    MCAPI ::BiomeManager& $getBiomeManager();


    MCFOLD ::OwnerPtrFactory<::Dimension, ::DerivedDimensionArguments&&> const& $getDimensionFactory() const;


    MCFOLD ::OwnerPtrFactory<::Dimension, ::DerivedDimensionArguments&&>& $getDimensionFactory();


    MCFOLD ::Factory<::BaseLightTextureImageBuilder, ::Level&, ::Scheduler&> const&

    $getLightTextureImageBuilderFactory() const;


    MCFOLD ::Factory<::BaseLightTextureImageBuilder, ::Level&, ::Scheduler&>& $getLightTextureImageBuilderFactory();


    MCAPI ::InternalComponentRegistry& $getInternalComponentRegistry() const;


    MCFOLD ::IWorldRegistriesProvider const& $getWorldRegistriesProvider() const;


    MCFOLD ::IWorldRegistriesProvider& $getWorldRegistriesProvider();


    MCAPI void $addListener(::LevelListener& listener);


    MCAPI void $removeListener(::LevelListener& listener);


    MCAPI void $tickEntities();


    MCAPI void $tickEntitySystems();


    MCAPI void $onPlayerDeath(::Player& player, ::ActorDamageSource const& source);


    MCAPI void $tick();


    MCAPI bool $explode(

        ::BlockSource& region,

        ::Actor*       source,

        ::Vec3 const&  pos,

        float          explosionRadius,

        bool           fire,

        bool           breaksBlocks,

        float          maxResistance,

        bool           allowUnderwater

    );


    MCAPI bool $explode(::Explosion& explosion);


    MCAPI void $denyEffect(::BlockSource& region, ::Vec3 const& pos);


    MCAPI void $potionSplash(::Vec3 const& pos, ::mce::Color const& color, bool instantaneousEffect);


    MCAPI bool $extinguishFire(::BlockSource& region, ::BlockPos const& pos, uchar face, ::Actor* source);


    MCAPI ::std::unique_ptr<::Path>

    $findPath(::Actor& from, int xBest, int yBest, int zBest, ::NavigationComponent& navigation);


    MCAPI ::std::unique_ptr<::Path> $findPath(::Actor& from, ::Actor const& to, ::NavigationComponent& navigation);


    MCAPI void $setSleepStatus(::PlayerSleepStatus const& status);


    MCAPI ::PlayerSleepStatus $getSleepStatus() const;


    MCAPI void $updateSleepingPlayerList();


    MCFOLD ::Bedrock::NonOwnerPointer<::ServerPlayerSleepManager> $getServerPlayerSleepManager();


    MCFOLD ::Bedrock::NonOwnerPointer<::ServerPlayerSleepManager const> $getServerPlayerSleepManager() const;


    MCAPI int $getTime() const;


    MCAPI void $setTime(int time);


    MCAPI uint $getSeed();


    MCAPI ::LevelSeed64 $getLevelSeed64() const;


    MCFOLD ::BlockPos const& $getSharedSpawnPos() const;


    MCAPI void $setDefaultSpawn(::BlockPos const& spawnPos);


    MCFOLD ::BlockPos const& $getDefaultSpawn() const;


    MCAPI void $setDefaultGameType(::GameType gameType);


    MCAPI ::GameType $getDefaultGameType() const;


    MCAPI void $setDifficulty(::SharedTypes::Legacy::Difficulty difficulty);


    MCAPI void $setMultiplayerGameIntent(bool multiplayerGame);


    MCAPI bool $getMultiplayerGameIntent() const;


    MCAPI void $setMultiplayerGame(bool multiplayerGame);


    MCAPI bool $isMultiplayerGame() const;


    MCAPI void $setLANBroadcastIntent(bool broadcast);


    MCAPI bool $getLANBroadcastIntent() const;


    MCAPI void $setLANBroadcast(bool broadcast);


    MCAPI bool $getLANBroadcast() const;


    MCAPI bool $hasXBLBroadcastIntent() const;


    MCAPI bool $hasXBLBroadcast() const;


    MCAPI bool $hasPlatformBroadcastIntent() const;


    MCAPI bool $hasPlatformBroadcast() const;


    MCAPI void $setHasLockedBehaviorPack(bool hasLocked);


    MCAPI void $setHasLockedResourcePack(bool hasLocked);


    MCAPI void $setCommandsEnabled(bool commandsEnabled);


    MCAPI void $setWorldTemplateOptionsUnlocked();


    MCAPI bool $hasLevelStorage() const;


    MCFOLD ::LevelStorage& $getLevelStorage();


    MCFOLD ::LevelStorage const& $getLevelStorage() const;


    MCFOLD ::LevelData& $getLevelData();


    MCFOLD ::LevelData const& $getLevelData() const;


    MCAPI ::PhotoStorage& $getPhotoStorage() const;


    MCAPI void $createPhotoStorage();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::PhotoManager> $getPhotoManager();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::PhotoManager const> $getPhotoManager() const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::EducationSettingsManager> $getEducationSettingsManager();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::EducationSettingsManager const> $getEducationSettingsManager() const;


    MCAPI void $save();


    MCAPI void $saveLevelData();


    MCAPI void $saveGameData();


    MCAPI ::std::shared_ptr<void*> $requestTimedStorageDeferment();


    MCFOLD ::TickingAreasManager& $getTickingAreasMgr();


    MCAPI void

    $addTickingAreaList(::DimensionType dimensionId, ::std::shared_ptr<::TickingAreaList> const& tickingAreas);


    MCAPI void $playSound(

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    );


    MCAPI void

    $playSound(::SharedTypes::Legacy::LevelSoundEvent type, ::Vec3 const& pos, float const volume, float const pitch);


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


    MCAPI void $playSound(

        ::IConstBlockSource const&             region,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    );


    MCAPI void $playSound(

        ::DimensionType                        dimension,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    );


    MCAPI ::PlayerEventCoordinator& $getRemotePlayerEventCoordinator();


    MCAPI ::ServerPlayerEventCoordinator& $getServerPlayerEventCoordinator();


    MCAPI ::ClientPlayerEventCoordinator& $getClientPlayerEventCoordinator();


    MCAPI ::ActorEventCoordinator& $getActorEventCoordinator();


    MCAPI ::BlockEventCoordinator& $getBlockEventCoordinator();


    MCAPI ::ItemEventCoordinator& $getItemEventCoordinator();


    MCAPI ::ServerNetworkEventCoordinator& $getServerNetworkEventCoordinator();


    MCAPI ::ScriptingEventCoordinator& $getScriptingEventCoordinator();


    MCAPI ::ScriptDeferredEventCoordinator& $getScriptDeferredEventCoordinator();


    MCAPI ::LevelEventCoordinator& $getLevelEventCoordinator();


    MCAPI void $handleLevelEvent(::SharedTypes::Legacy::LevelEvent type, ::Vec3 const& pos, int data);


    MCAPI void $handleLevelEvent(::SharedTypes::Legacy::LevelEvent type, ::CompoundTag const& data);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelEventManager> $getLevelEventManager();


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


    MCAPI void $handleStopAllSounds();


    MCAPI void $handleStopMusicEvent();


    MCAPI void $broadcastLevelEvent(

        ::SharedTypes::Legacy::LevelEvent      type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::UserEntityIdentifierComponent const* userIdentifier

    );


    MCAPI void $broadcastLevelEvent(

        ::SharedTypes::Legacy::LevelEvent      type,

        ::CompoundTag const&                   tag,

        ::UserEntityIdentifierComponent const* userIdentifier

    );


    MCAPI void

    $broadcastLocalEvent(::BlockSource& region, ::SharedTypes::Legacy::LevelEvent type, ::Vec3 const& pos, int data);


    MCAPI void $broadcastLocalEvent(

        ::BlockSource&                    region,

        ::SharedTypes::Legacy::LevelEvent type,

        ::Vec3 const&                     pos,

        ::Block const&                    block

    );


    MCAPI void $broadcastSoundEvent(

        ::BlockSource&                         region,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        ::Block const&                         block,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    );


    MCAPI void $broadcastSoundEvent(

        ::BlockSource&                         region,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    );


    MCAPI void $broadcastSoundEvent(

        ::Dimension&                           dimension,

        ::SharedTypes::Legacy::LevelSoundEvent type,

        ::Vec3 const&                          pos,

        int                                    data,

        ::ActorSoundIdentifier const&          actorSoundIdentifier,

        bool                                   isGlobal

    );


    MCAPI void $broadcastActorEvent(::Actor& actor, ::ActorEvent eventId, int data) const;


    MCAPI ::Bedrock::NonOwnerPointer<::ActorEventBroadcaster const> $getActorEventBroadcaster() const;


    MCAPI void $addChunkViewTracker(::std::weak_ptr<::ChunkViewSource> chunkViewSource);


    MCAPI void $onChunkReload(::Bounds const& bound);


    MCAPI int $getActivePlayerCount() const;


    MCAPI int $getActiveUsersCount() const;


    MCAPI void $forEachPlayer(::std::function<bool(::Player&)> callback);


    MCAPI void $forEachPlayer(::std::function<bool(::Player const&)> callback) const;


    MCAPI void $forEachUser(::std::function<bool(::EntityContext&)> callback);


    MCAPI void $forEachUser(::std::function<bool(::EntityContext const&)> callback) const;


    MCAPI ::Player* $findPlayer(::std::function<bool(::Player const&)> pred) const;


    MCAPI ::Player* $findPlayer(::std::function<bool(::WeakEntityRef const&)> pred) const;


    MCAPI int $getUserCount() const;


    MCAPI int $countUsersWithMatchingNetworkId(::NetworkIdentifier const& networkId) const;


    MCAPI ::std::vector<::OwnerPtr<::EntityContext>> const& $getUsers() const;


    MCAPI ::std::vector<::OwnerPtr<::EntityContext>> const& $getEntities() const;


    MCAPI void $onSourceCreated(::BlockSource& source);


    MCAPI void $onSourceDestroyed(::BlockSource& source);


    MCFOLD void $onSubChunkLoaded(

        ::ChunkSource& source,

        ::LevelChunk&  lc,

        short          absoluteSubChunkIndex,

        bool           subChunkVisibilityChanged

    );


    MCFOLD ::Bedrock::NonOwnerPointer<::SubChunkManager> $getSubChunkManager();


    MCAPI void $onChunkLoaded(::ChunkSource& source, ::LevelChunk& lc);


    MCAPI void $onChunkReloaded(::ChunkSource& source, ::LevelChunk& lc);


    MCFOLD ::LevelChunkMetaDataManager* $getLevelChunkMetaDataManager();


    MCAPI void $onChunkDiscarded(::LevelChunk& lc);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelChunkEventManager> $getLevelChunkEventManager();


    MCAPI void $queueEntityDestruction(::OwnerPtr<::EntityContext> entity);


    MCAPI ::OwnerPtr<::EntityContext> $removeEntity(::Actor& actor);


    MCAPI ::OwnerPtr<::EntityContext> $removeEntity(::WeakEntityRef entityRef);


    MCAPI void $forceRemoveEntity(::Actor& actor);


    MCAPI void $forceRemoveEntityfromWorld(::Actor& actor);


    MCAPI void $forceFlushRemovedPlayers();


    MCFOLD void $loadFunctionManager();


    MCAPI void $levelCleanupQueueEntityRemoval(::OwnerPtr<::EntityContext> entity);


    MCAPI void $registerTemporaryPointer(::_TickPtr& ptr);


    MCAPI void $unregisterTemporaryPointer(::_TickPtr& ptr);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TempEPtrManager> $getTempEPtrManager();


    MCAPI bool $destroyBlock(

        ::BlockSource&              region,

        ::BlockPos const&           pos,

        bool                        dropResources,

        ::BlockChangeContext const& changeSourceContext

    );


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelBlockDestroyer> $getLevelBlockDestroyer();


    MCAPI void $upgradeStorageVersion(::StorageVersion v);


    MCAPI void $suspendAndSave();


    MCAPI void $sendServerLegacyParticle(::ParticleType id, ::Vec3 const& pos, ::Vec3 const& dir, int data);


    MCAPI ::Particle* $addParticle(

        ::ParticleType       id,

        ::Vec3 const&        pos,

        ::Vec3 const&        dir,

        int                  data,

        ::CompoundTag const* tag,

        bool                 isGlobal

    );


    MCAPI void

    $spawnParticleEffect(::std::string const& effectName, ::Vec3 const& spawnLocation, ::Dimension* dimension);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ServerParticleManager> $getServerParticleManager();


    MCAPI void $addParticleEffect(

        ::HashedString const&      effect,

        ::Vec3 const&              emitterPosition,

        ::MolangVariableMap const& molangVariables

    );


    MCAPI void $addTerrainParticleEffect(

        ::BlockPos const& pos,

        ::Block const&    block,

        ::Vec3 const&     emitterPosition,

        float             intensity,

        float             velocityScalar,

        float             emitterRadius

    );


    MCAPI void $addTerrainSlideEffect(

        ::BlockPos const& pos,

        ::Block const&    block,

        ::Vec3 const&     emitterPosition,

        float             intensity,

        float             velocityScalar,

        float             emitterRadius

    );


    MCAPI void $addBreakingItemParticleEffect(

        ::Vec3 const&                     pos,

        ::BreakingItemParticleData const& data,

        ::ResolvedItemIconInfo const&     textureInfo

    );


    MCAPI void $addBiomeTintedParticleEffect(

        ::HashedString const&         effect,

        ::BlockPos const&             pos,

        ::Block const&                block,

        ::std::optional<::mce::Color> overrideColor

    );


    MCAPI ::ActorUniqueID $getNewUniqueID();


    MCAPI ::ActorRuntimeID $getNextRuntimeID();


    MCAPI ::std::vector<::ChunkPos> const& $getTickingOffsets() const;


    MCAPI ::std::vector<::ChunkPos> const& $getClientTickingOffsets() const;


    MCAPI ::std::vector<::ChunkPos>

    $getSortedPositionsFromClientOffsets(::std::vector<::ChunkPos> const& centers) const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ChunkTickOffsetManager const> $getChunkTickOffsetManager() const;


    MCAPI bool $isExporting() const;


    MCAPI void $setIsExporting(bool IsExporting);


    MCAPI ::SavedDataStorage& $getSavedData();


    MCAPI ::MapItemSavedData* $getMapSavedData(::ActorUniqueID const uuid);


    MCFOLD ::MapItemSavedData* $getMapSavedData(::CompoundTag const& instance);


    MCFOLD ::MapItemSavedData* $getMapSavedData(::CompoundTag const* instance);


    MCAPI void $requestMapInfo(::ActorUniqueID const uuid, bool forceUpdate);


    MCAPI ::ActorUniqueID $expandMapByID(::ActorUniqueID const uuid, bool wasInit);


    MCAPI bool $copyAndLockMap(::ActorUniqueID const originalMapUuid, ::ActorUniqueID const newMapUuid);


    MCAPI ::MapItemSavedData& $createMapSavedData(

        ::ActorUniqueID const& uuid,

        ::BlockPos const&      origin,

        ::DimensionType        dimension,

        int                    returnScaleLevel

    );


    MCAPI ::MapItemSavedData& $createMapSavedData(

        ::std::vector<::ActorUniqueID> const& mapIds,

        ::BlockPos const&                     origin,

        ::DimensionType                       dimension,

        int                                   returnScaleLevel

    );


    MCAPI ::Core::PathBuffer<::std::string> $getScreenshotsFolder() const;


    MCAPI ::std::string $getLevelId() const;


    MCAPI void $setLevelId(::std::string LevelId);


    MCFOLD ::TaskGroup& $getSyncTasksGroup();


    MCFOLD ::TaskGroup& $getIOTasksGroup();


    MCFOLD ::ResourcePackManager* $getClientResourcePackManager() const;


    MCFOLD ::ResourcePackManager* $getServerResourcePackManager() const;


    MCFOLD ::TradeTables* $getTradeTables();


    MCFOLD void $decrementTagCache(

        ::std::string const&                                                      tag,

        ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& tagRegistry

    );


    MCFOLD void $incrementTagCache(

        ::std::string const&                                                      tag,

        ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& tagRegistry

    );


    MCFOLD ::Bedrock::NonOwnerPointer<::TagCacheManager> $getTagCacheManager();


    MCAPI bool $isEdu() const;


    MCFOLD ::ActorFactory& $getActorFactory();


    MCFOLD ::ActorFactory const& $getActorFactory() const;


    MCFOLD ::ActorInfoRegistry* $getActorInfoRegistry();


    MCAPI ::StackRefResult<::EntityRegistry> $getEntityRegistry();


    MCAPI ::StackRefResult<::EntityRegistry const> $getEntityRegistry() const;


    MCAPI ::EntitySystems& $getEntitySystems();


    MCFOLD ::WeakRef<::EntityContext> $getLevelEntity();


    MCFOLD ::WeakRef<::EntityContext const> $getLevelEntity() const;


    MCFOLD ::Bedrock::NonOwnerPointer<::VolumeEntityManagerServer> $tryGetVolumeEntityManagerServer() const;


    MCFOLD void $runCommand(

        ::HashedString const&     commandStr,

        ::CommandOrigin&          origin,

        ::CommandOriginSystem     originSystem,

        ::CurrentCmdVersion const commandVersion

    );


    MCFOLD void $runCommand(::Command& command, ::CommandOrigin& origin, ::CommandOriginSystem originSystem);


    MCAPI ::PlayerCapabilities::ISharedController const& $getCapabilities() const;


    MCFOLD ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& $getTagRegistry();


    MCAPI ::PlayerMovementSettings const& $getPlayerMovementSettings() const;


    MCAPI void $setPlayerMovementSettings(::PlayerMovementSettings const& settings);


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::PlayerMovementSettingsManager> $getPlayerMovementSettingsManager();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::PlayerMovementSettingsManager const>

    $getPlayerMovementSettingsManager() const;


    MCAPI ::TickDeathSettings const& $getTickDeathSettings() const;


    MCAPI void $setTickDeathSettings(::TickDeathSettings const& settings);


    MCFOLD bool $canUseSkin(

        ::SerializedSkin const&    skin,

        ::NetworkIdentifier const& networkIdentifier,

        ::ActorUniqueID const&     playerId

    ) const;


    MCFOLD ::Bedrock::NonOwnerPointer<::TrustedSkinHelper const> $getTrustedSkinHelper() const;


    MCFOLD ::Bedrock::NonOwnerPointer<::CameraRegistry const> $getCameraRegistry() const;


    MCFOLD ::Bedrock::NonOwnerPointer<::CameraRegistry> $getCameraRegistry();


    MCFOLD ::Bedrock::NonOwnerPointer<::EntitySystems> $getCameraSystems();


    MCAPI ::PositionTrackingDB::PositionTrackingDBClient* $getPositionTrackerDBClient() const;


    MCFOLD ::PositionTrackingDB::PositionTrackingDBServer* $getPositionTrackerDBServer() const;


    MCAPI void $flushRunTimeLighting();


    MCAPI void $loadBlockDefinitionGroup(::Experiments const& experiments);


    MCAPI void $initializeBlockDefinitionGroup();


    MCAPI ::Bedrock::NonOwnerPointer<::IUnknownBlockTypeRegistry> $getUnknownBlockTypeRegistry();


    MCAPI bool $isClientSideGenerationEnabled();


    MCAPI bool $blockNetworkIdsAreHashes();


    MCAPI ::ItemRegistryRef $getItemRegistry() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::BlockTypeRegistry> $getBlockTypeRegistry() const;


    MCFOLD ::Level* $asLevel();


    MCAPI bool $use3DBiomeMaps() const;


    MCAPI void $pauseAndFlushTaskGroups();


    MCFOLD ::DimensionManager& $getDimensionManager();


    MCFOLD ::DimensionManager const& $getDimensionManager() const;


    MCFOLD void $subChunkTickAndSendRequests();


    MCAPI void $_subTick();


    MCFOLD ::StackRefResult<::PauseManager> $getPauseManager();


    MCFOLD ::StackRefResult<::PauseManager const> $getPauseManager() const;


    MCAPI bool $isClientSide() const;


    MCAPI ::std::unordered_map<::mce::UUID, ::PlayerListEntry> const& $getPlayerList() const;


    MCAPI ::std::string const& $getPlayerXUID(::mce::UUID const& uuid) const;


    MCAPI ::std::string const& $getPlayerPlatformOnlineId(::mce::UUID const& uuid) const;


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::PlayerListManager> $getPlayerListManager();


    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::PlayerListManager const> $getPlayerListManager() const;


    MCAPI ::std::vector<::WeakEntityRef> const& $getActiveUsers() const;


    MCFOLD void $notifySubChunkRequestManager(::SubChunkPacket const& packet);


    MCFOLD ::SubChunkRequestManager* $getSubChunkRequestManager();


    MCAPI ::std::vector<::Actor*> $getRuntimeActorList() const;


    MCFOLD ::PacketSender* $getPacketSender() const;


    MCAPI ::Bedrock::NonOwnerPointer<::NetEventCallback> $getNetEventCallback() const;


    MCAPI void $setNetEventCallback(::Bedrock::NonOwnerPointer<::NetEventCallback> val);


    MCAPI ::gsl::not_null<::StackRefResult<::ILevelRandom>> $getILevelRandom();


    MCAPI ::IRandom& $getIRandom() const;


    MCAPI ::Random& $getRandom() const;


    MCFOLD ::Random& $getThreadRandom() const;


    MCAPI ::HitResult& $getHitResult();


    MCAPI ::HitResult& $getLiquidHitResult();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::HitResultWrapper> $getHitResultWrapper();


    MCFOLD ::std::string const& $getImmersiveReaderString() const;


    MCAPI void $setImmersiveReaderString(::std::string newString);


    MCAPI ::AdventureSettings& $getAdventureSettings();


    MCAPI ::AdventureSettings const& $getAdventureSettings() const;


    MCAPI ::GameRules const& $getGameRules() const;


    MCAPI ::GameRules& $getGameRules();


    MCAPI bool $hasStartWithMapEnabled() const;


    MCAPI bool $isEditorWorld() const;


    MCAPI bool $isHardcore() const;


    MCAPI ::Abilities& $getDefaultAbilities();


    MCAPI ::PermissionsHandler& $getDefaultPermissions();


    MCAPI ::PermissionsHandler const& $getDefaultPermissions() const;


    MCFOLD bool $getTearingDown() const;


    MCAPI void $takePicture(

        ::cg::ImageBuffer&                                              outImage,

        ::Actor*                                                        camera,

        ::Actor*                                                        target,

        ::ScreenshotOptions&                                            screenshotOptions,

        ::std::function<void(::cg::ImageBuffer&, ::ScreenshotOptions&)> completedScreenshotCallback

    );


    MCFOLD ::LevelSoundManager& $getLevelSoundManager();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::SoundPlayerInterface> $getSoundPlayer() const;


    MCAPI void $setSimPaused(bool value);


    MCAPI bool $getSimPaused();


    MCAPI void $setFinishedInitializing();


    MCFOLD ::LootTables& $getLootTables();


    MCAPI void $updateWeather(float rainLevel, int rainTime, float lightningLevel, int lightningTime);


    MCAPI int $getNetherScale() const;


    MCFOLD ::Scoreboard& $getScoreboard();


    MCFOLD ::Scoreboard const& $getScoreboard() const;


    MCFOLD ::Scoreboard* $tryGetScoreboard();


    MCAPI ::LayeredAbilities* $getPlayerAbilities(::ActorUniqueID const& playerId);


    MCAPI void $setPlayerAbilities(::ActorUniqueID const& playerId, ::LayeredAbilities const& abilities);


    MCAPI void $sendAllPlayerAbilities(::Player const& playerReference);


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::PlayerAbilitiesManager> $getPlayerAbilitiesManager();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::PlayerPermissionsManager> $getPlayerPermissionsManager();


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::PlayerPermissionsSynchroniser> $getPlayerPermissionsSynchroniser();


    MCFOLD ::Recipes& $getRecipes() const;


    MCFOLD ::BlockReducer* $getBlockReducer() const;


    MCFOLD ::std::weak_ptr<::TrimPatternRegistry const> $getTrimPatternRegistry() const;


    MCFOLD ::std::weak_ptr<::TrimPatternRegistry> $getTrimPatternRegistry();


    MCFOLD ::std::weak_ptr<::TrimMaterialRegistry const> $getTrimMaterialRegistry() const;


    MCFOLD ::std::weak_ptr<::TrimMaterialRegistry> $getTrimMaterialRegistry();


    MCAPI ::BlockType const& $getRegisteredBorderBlock() const;


    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelChunkPerformanceTelemetry> $getLevelChunkPerformanceTelemetry();


    MCFOLD ::cereal::ReflectionCtx& $cerealContext();


    MCFOLD ::cereal::ReflectionCtx const& $cerealContext() const;


    MCFOLD ::Bedrock::NonOwnerPointer<::ChunkGenerationManager> $getChunkGenerationManager();


    MCFOLD ::Bedrock::NonOwnerPointer<::ChunkGenerationManager const> $getChunkGenerationManager() const;


    MCAPI void $digestServerBlockProperties(::StartGamePacket const& packet);


    MCAPI ::MolangPackSettingsCache* $getMolangPackSettingsCache();


    MCFOLD ::PlayerDeathManager* $_getPlayerDeathManager();


    MCAPI void $_initializeMapDataManager();


    MCFOLD ::cereal::ReflectionCtx& $_cerealContext();


    MCAPI void $_onLowMemory();

    // NOLINTEND


public:

    // vftables

    // NOLINTBEGIN

    MCNAPI static void** $vftableForIWorldRegistriesProvider();


    MCNAPI static void** $vftableForBlockSourceListener();


    MCNAPI static void** $vftableForILevel();

    // NOLINTEND

};


Abilities
Definition Abilities.h:15

ActorAnimationControllerGroup
Definition ActorAnimationControllerGroup.h:26

ActorAnimationGroup
Definition ActorAnimationGroup.h:25

ActorDamageSource
Definition ActorDamageSource.h:18

ActorDefinitionGroup
Definition ActorDefinitionGroup.h:35

ActorDimensionTransferManager
Definition ActorDimensionTransferManager.h:19

ActorEventBroadcaster
Definition ActorEventBroadcaster.h:5

ActorEventCoordinator
Definition ActorEventCoordinator.h:21

ActorFactory
Definition ActorFactory.h:33

ActorFetcher
Definition ActorFetcher.h:15

ActorGarbageCollector
Definition ActorGarbageCollector.h:13

ActorInfoRegistry
Definition ActorInfoRegistry.h:10

ActorManager
Definition ActorManager.h:29

ActorRuntimeIDManager
Definition ActorRuntimeIDManager.h:17

ActorRuntimeID
Definition ActorRuntimeID.h:5

ActorSoundIdentifier
Definition ActorSoundIdentifier.h:16

Actor
Definition Actor.h:102

ArmorTrimUnloader
Definition ArmorTrimUnloader.h:5

AutomaticID
Definition AutomaticID.h:6

AutomationBehaviorTreeGroup
Definition AutomationBehaviorTreeGroup.h:13

AutonomousActorManager
Definition AutonomousActorManager.h:26

BaseLightTextureImageBuilder
Definition BaseLightTextureImageBuilder.h:12

Bedrock::NonOwnerPointer
Definition NonOwnerPointer.h:9

Bedrock::UniqueOwnerPointer
Definition UniqueOwnerPointer.h:11

BehaviorFactory
Definition BehaviorFactory.h:13

BiomeComponentFactory
Definition BiomeComponentFactory.h:22

BiomeManager
Definition BiomeManager.h:27

BiomeRegistry
Definition BiomeRegistry.h:37

BlockActorLevelListener
Definition BlockActorLevelListener.h:14

BlockChangeContext
Definition BlockChangeContext.h:10

BlockDefinitionGroup
Definition BlockDefinitionGroup.h:39

BlockEventCoordinator
Definition BlockEventCoordinator.h:21

BlockPalette
Definition BlockPalette.h:19

BlockPos
Definition BlockPos.h:17

BlockReducer
Definition BlockReducer.h:12

BlockSourceListener
Definition BlockSourceListener.h:18

BlockSource
Definition BlockSource.h:66

BlockTypeRegistry
Definition BlockTypeRegistry.h:28

BlockType
Definition BlockType.h:84

Block
Definition Block.h:38

BossEventSubscriptionManager
Definition BossEventSubscriptionManager.h:17

CameraPresets
Definition CameraPresets.h:22

CameraRegistry
Definition CameraRegistry.h:5

ChangeDimensionRequest
Definition ChangeDimensionRequest.h:15

ChunkGenerationManager
Definition ChunkGenerationManager.h:17

ChunkPos
Definition ChunkPos.h:11

ChunkSource
Definition ChunkSource.h:36

ChunkTickOffsetManager
Definition ChunkTickOffsetManager.h:10

ChunkTickRangeManager
Definition ChunkTickRangeManager.h:18

ChunkViewSource
Definition ChunkViewSource.h:22

ChunkViewTrackerManager
Definition ChunkViewTrackerManager.h:16

ClientPlayerEventCoordinator
Definition ClientPlayerEventCoordinator.h:8

CommandOrigin
Definition CommandOrigin.h:32

Command
Definition Command.h:17

CompoundTag
Definition CompoundTag.h:13

ContainerRegistry
Definition ContainerRegistry.h:28

DimensionConversionData
Definition DimensionConversionData.h:8

DimensionDefinitionGroup
Definition DimensionDefinitionGroup.h:18

DimensionFactory
Definition DimensionFactory.h:21

DimensionManager
Definition DimensionManager.h:24

Dimension
Definition Dimension.h:83

DisplayActorManager
Definition DisplayActorManager.h:5

EducationSettingsManager
Definition EducationSettingsManager.h:10

EntityContext
Definition EntityContext.h:16

EntityRegistry
Definition EntityRegistry.h:10

EntitySystemsManager
Definition EntitySystemsManager.h:16

EntitySystems
Definition EntitySystems.h:24

EventCoordinatorManager
Definition EventCoordinatorManager.h:25

Experiments
Definition Experiments.h:14

Explosion
Definition Explosion.h:23

FeatureRegistry
Definition FeatureRegistry.h:18

FeatureTypeFactory
Definition FeatureTypeFactory.h:20

GameRules
Definition GameRules.h:22

GameplayUserManager
Definition GameplayUserManager.h:22

HashedString
Definition HashedString.h:5

HitResultWrapper
Definition HitResultWrapper.h:17

HitResult
Definition HitResult.h:17

IConstBlockSource
Definition IConstBlockSource.h:25

IEntityRegistryOwner
Definition IEntityRegistryOwner.h:14

ILevelRandom
Definition ILevelRandom.h:11

ILevel
Definition ILevel.h:211

IMinecraftEventing
Definition IMinecraftEventing.h:149

IRandom
Definition IRandom.h:13

IUnknownBlockTypeRegistry
Definition IUnknownBlockTypeRegistry.h:14

IWorldRegistriesProvider
Definition IWorldRegistriesProvider.h:25

InternalComponentRegistry
Definition InternalComponentRegistry.h:13

ItemEventCoordinator
Definition ItemEventCoordinator.h:19

ItemRegistryRef
Definition ItemRegistryRef.h:34

JigsawStructureRegistry
Definition JigsawStructureRegistry.h:22

LayeredAbilities
Definition LayeredAbilities.h:18

LevelBlockDestroyer
Definition LevelBlockDestroyer.h:5

LevelChunkEventManager
Definition LevelChunkEventManager.h:18

LevelChunkMetaDataManager
Definition LevelChunkMetaDataManager.h:23

LevelChunkPerformanceTelemetry
Definition LevelChunkPerformanceTelemetry.h:14

LevelChunkSaveManager
Definition LevelChunkSaveManager.h:22

LevelChunk
Definition LevelChunk.h:78

LevelCrashDumpManager
Definition LevelCrashDumpManager.h:9

LevelData
Definition LevelData.h:49

LevelEventCoordinator
Definition LevelEventCoordinator.h:25

LevelEventManager
Definition LevelEventManager.h:23

LevelListener
Definition LevelListener.h:28

LevelSeed64
Definition LevelSeed64.h:5

LevelSettings
Definition LevelSettings.h:38

LevelSoundManager
Definition LevelSoundManager.h:22

LevelStorageManager
Definition LevelStorageManager.h:27

LevelStorage
Definition LevelStorage.h:25

Level
Definition Level.h:247

Level::$vftableForILevel
static MCAPI void ** $vftableForILevel()

Level::$vftableForBlockSourceListener
static MCAPI void ** $vftableForBlockSourceListener()

Level::$vftableForIWorldRegistriesProvider
static MCAPI void ** $vftableForIWorldRegistriesProvider()

LinkedAssetValidator
Definition LinkedAssetValidator.h:8

LoadingScreenIdManager
Definition LoadingScreenIdManager.h:5

LootTables
Definition LootTables.h:11

MapItemSavedData
Definition MapItemSavedData.h:33

Mob
Definition Mob.h:47

MolangPackSettingsCache
Definition MolangPackSettingsCache.h:10

MolangVariableMap
Definition MolangVariableMap.h:16

NavigationComponent
Definition NavigationComponent.h:22

NetEventCallback
Definition NetEventCallback.h:244

NetworkIdentifier
Definition NetworkIdentifier.h:10

NpcDialogueStorage
Definition NpcDialogueStorage.h:14

OwnerPtr
Definition OwnerPtr.h:7

PacketSender
Definition PacketSender.h:17

ParticleProvider
Definition ParticleProvider.h:25

Particle
Definition Particle.h:5

Path
Definition Path.h:16

PauseManager
Definition PauseManager.h:9

PermissionsHandler
Definition PermissionsHandler.h:14

PhotoItemSavedDataCollection
Definition PhotoItemSavedDataCollection.h:11

PhotoManager
Definition PhotoManager.h:19

PhotoStorage
Definition PhotoStorage.h:10

PlayerAbilitiesManager
Definition PlayerAbilitiesManager.h:19

PlayerDeathManager
Definition PlayerDeathManager.h:20

PlayerDimensionTransferManager
Definition PlayerDimensionTransferManager.h:26

PlayerEventCoordinator
Definition PlayerEventCoordinator.h:22

PlayerLimboActorManager
Definition PlayerLimboActorManager.h:21

PlayerListEntry
Definition PlayerListEntry.h:20

PlayerListManager
Definition PlayerListManager.h:23

PlayerLocationReceiver
Definition PlayerLocationReceiver.h:5

PlayerLocationSender
Definition PlayerLocationSender.h:18

PlayerMovementSettingsManager
Definition PlayerMovementSettingsManager.h:14

PlayerPermissionsManager
Definition PlayerPermissionsManager.h:21

PlayerPermissionsSynchroniser
Definition PlayerPermissionsSynchroniser.h:5

PlayerSleepManager
Definition PlayerSleepManager.h:9

PlayerTickManager
Definition PlayerTickManager.h:16

Player
Definition Player.h:123

PortalForcer
Definition PortalForcer.h:25

ProjectileFactory
Definition ProjectileFactory.h:16

PropertyGroupManager
Definition PropertyGroupManager.h:13

Random
Definition Random.h:10

Recipes
Definition Recipes.h:35

ResourcePackManager
Definition ResourcePackManager.h:24

SavedDataStorage
Definition SavedDataStorage.h:11

Scheduler
Definition Scheduler.h:13

Scoreboard
Definition Scoreboard.h:34

ScriptDeferredEventCoordinator
Definition ScriptDeferredEventCoordinator.h:18

ScriptingEventCoordinator
Definition ScriptingEventCoordinator.h:14

SerializedSkin
Definition SerializedSkin.h:21

ServerLevelEventCoordinator
Definition ServerLevelEventCoordinator.h:15

ServerLevel
Definition ServerLevel.h:62

ServerNetworkEventCoordinator
Definition ServerNetworkEventCoordinator.h:17

ServerParticleManager
Definition ServerParticleManager.h:5

ServerPlayerEventCoordinator
Definition ServerPlayerEventCoordinator.h:8

ServerPlayerSleepManager
Definition ServerPlayerSleepManager.h:25

SoundPlayerInterface
Definition SoundPlayerInterface.h:20

Spawner
Definition Spawner.h:40

StartGamePacket
Definition StartGamePacket.h:29

StrictEntityContext
Definition StrictEntityContext.h:8

StructureManager
Definition StructureManager.h:43

StructureSpawnRegistry
Definition StructureSpawnRegistry.h:14

SubChunkManager
Definition SubChunkManager.h:24

SubChunkPacket
Definition SubChunkPacket.h:19

SubChunkRequestManager
Definition SubChunkRequestManager.h:16

SurfaceBuilderRegistry
Definition SurfaceBuilderRegistry.h:13

TagCacheManager
Definition TagCacheManager.h:17

TagRegistry
Definition TagRegistry.h:9

TaskGroup
Definition TaskGroup.h:53

TempEPtrManager
Definition TempEPtrManager.h:10

TickDeathSettingsManager
Definition TickDeathSettingsManager.h:10

TickDeltaTimeManager
Definition TickDeltaTimeManager.h:5

TickTimeManager
Definition TickTimeManager.h:11

TickingAreaList
Definition TickingAreaList.h:15

TickingAreasManager
Definition TickingAreasManager.h:29

TradeTables
Definition TradeTables.h:19

TrimMaterialRegistry
Definition TrimMaterialRegistry.h:11

TrimPatternRegistry
Definition TrimPatternRegistry.h:11

TrustedSkinHelper
Definition TrustedSkinHelper.h:5

UniqueIDManager
Definition UniqueIDManager.h:13

UserEntityIdentifierComponent
Definition UserEntityIdentifierComponent.h:12

VanillaActorEventListenerManager
Definition VanillaActorEventListenerManager.h:12

Vec3
Definition Vec3.h:10

VolumeEntityManagerServer
Definition VolumeEntityManagerServer.h:20

WeakEntityRef
Definition WeakEntityRef.h:14

WeakRef
Definition WeakRef.h:8

WeatherManager
Definition WeatherManager.h:18

_TickPtr
Definition _TickPtr.h:5

cg::ImageBuffer
Definition ImageBuffer.h:12

mce::Color
Definition Color.h:13

mce::UUID
Definition UUID.h:7

ActorUniqueID
Definition ActorUniqueID.h:5

AdventureSettings
Definition AdventureSettings.h:5

Bounds
Definition Bounds.h:8

BreakingItemParticleData
Definition BreakingItemParticleData.h:8

DerivedDimensionArguments
Definition DerivedDimensionArguments.h:14

IDType
Definition IDType.h:6

LevelTagIDType
Definition LevelTagIDType.h:5

LevelTagSetIDType
Definition LevelTagSetIDType.h:5

NetworkPermissions
Definition NetworkPermissions.h:5

PlayerMovementSettings
Definition PlayerMovementSettings.h:9

PlayerSleepStatus
Definition PlayerSleepStatus.h:5

ResolvedItemIconInfo
Definition ResolvedItemIconInfo.h:8

ScreenshotOptions
Definition ScreenshotOptions.h:5

TickDeathSettings
Definition TickDeathSettings.h:5

Tick
Definition Tick.h:5