World.h

Go to the documentation of this file.

#pragma once

#define MAX_PLAYERS 65535

#include <functional>

#include "Simulator/SimulatorManager.h"
#include "ChunkMap.h"
#include "WorldStorage/WorldStorage.h"
#include "ChunkGeneratorThread.h"
#include "ChunkSender.h"
#include "Defines.h"
#include "LightingThread.h"
#include "IniFile.h"
#include "Item.h"
#include "Mobs/Monster.h"
#include "Entities/ProjectileEntity.h"
#include "Entities/Boat.h"
#include "ForEachChunkProvider.h"
#include "Scoreboard.h"
#include "MapManager.h"
#include "Blocks/WorldInterface.h"
#include "Blocks/BroadcastInterface.h"
#include "EffectID.h"



class cFireSimulator;
class cFluidSimulator;
class cSandSimulator;
class cRedstoneSimulator;
class cItem;
class cPlayer;
class cClientHandle;
typedef std::shared_ptr<cClientHandle> cClientHandlePtr;
typedef std::list<cClientHandlePtr> cClientHandlePtrs;
typedef std::list<cClientHandle *> cClientHandles;
class cEntity;
class cChunkGenerator;  // The thread responsible for generating chunks
class cBeaconEntity;
class cBrewingstandEntity;
class cChestEntity;
class cCuboid;
class cDispenserEntity;
class cFlowerPotEntity;
class cFurnaceEntity;
class cNoteEntity;
class cMobHeadEntity;
class cCompositeChat;
class cSetChunkData;
class cDeadlockDetect;
class cUUID;

typedef std::list< cPlayer * > cPlayerList;
typedef std::list< std::pair< std::unique_ptr<cPlayer>, cWorld * > > cAwaitingPlayerList;

typedef std::unique_ptr<cSetChunkData> cSetChunkDataPtr;
typedef std::vector<cSetChunkDataPtr> cSetChunkDataPtrs;





class cWorld  // tolua_export
    final:
    public cForEachChunkProvider,
    public cWorldInterface,
    public cBroadcastInterface
// tolua_begin
{
public:
    // tolua_end

    class cLock :
        public cCSLock
    {
        typedef cCSLock super;
    public:
        cLock(cWorld & a_World);
    };

    static const char * GetClassStatic(void)  // Needed for ManualBindings's ForEach templates
    {
        return "cWorld";
    }

    // tolua_begin

    bool IsSavingEnabled(void) const { return m_IsSavingEnabled; }

    void SetSavingEnabled(bool a_IsSavingEnabled) { m_IsSavingEnabled = a_IsSavingEnabled; }

    int GetTicksUntilWeatherChange(void) const { return m_WeatherInterval; }

    virtual bool IsDaylightCycleEnabled(void) const { return m_IsDaylightCycleEnabled; }

    virtual void SetDaylightCycleEnabled(bool a_IsDaylightCycleEnabled)
    {
        m_IsDaylightCycleEnabled = a_IsDaylightCycleEnabled;
        BroadcastTimeUpdate();
    }

    virtual Int64 GetWorldAge (void) const override { return std::chrono::duration_cast<cTickTimeLong>(m_WorldAge).count(); }
    virtual int GetTimeOfDay(void) const override { return std::chrono::duration_cast<cTickTime>(m_TimeOfDay).count(); }

    void SetTicksUntilWeatherChange(int a_WeatherInterval)
    {
        m_WeatherInterval = a_WeatherInterval;
    }

    virtual void SetTimeOfDay(int a_TimeOfDay) override
    {
        m_TimeOfDay = cTickTime(a_TimeOfDay);
        UpdateSkyDarkness();
        BroadcastTimeUpdate();
    }

    int GetDefaultWeatherInterval(eWeather a_Weather);

    eGameMode GetGameMode(void) const { return m_GameMode; }

    bool IsGameModeCreative(void) const { return (m_GameMode == gmCreative); }

    bool IsGameModeSurvival(void) const { return (m_GameMode == gmSurvival); }

    bool IsGameModeAdventure(void) const { return (m_GameMode == gmAdventure); }

    bool IsGameModeSpectator(void) const { return (m_GameMode == gmSpectator); }

    bool IsPVPEnabled(void) const { return m_bEnabledPVP; }

    bool IsDeepSnowEnabled(void) const { return m_IsDeepSnowEnabled; }

    bool ShouldLavaSpawnFire(void) const { return m_ShouldLavaSpawnFire; }

    bool VillagersShouldHarvestCrops(void) const { return m_VillagersShouldHarvestCrops; }

    virtual eDimension GetDimension(void) const override { return m_Dimension; }

    virtual int GetHeight(int a_BlockX, int a_BlockZ) override;

    // tolua_end

    bool TryGetHeight(int a_BlockX, int a_BlockZ, int & a_Height);  // Exported in ManualBindings.cpp

    // Broadcast respective packets to all clients of the chunk where the event is taking place
    // Implemented in Broadcaster.cpp
    // (Please keep these alpha-sorted)
    virtual void BroadcastAttachEntity       (const cEntity & a_Entity, const cEntity & a_Vehicle) override;
    virtual void BroadcastBlockAction        (Vector3i a_BlockPos, Byte a_Byte1, Byte a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = nullptr) override;  // Exported in ManualBindings_World.cpp
    virtual void BroadcastBlockBreakAnimation(UInt32 a_EntityID, Vector3i a_BlockPos, Int8 a_Stage, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastBlockEntity        (Vector3i a_BlockPos, const cClientHandle * a_Exclude = nullptr) override;  

    // tolua_begin
    virtual void BroadcastChat       (const AString & a_Message, const cClientHandle * a_Exclude = nullptr, eMessageType a_ChatPrefix = mtCustom) override;
    virtual void BroadcastChatInfo   (const AString & a_Message, const cClientHandle * a_Exclude = nullptr) override { BroadcastChat(a_Message, a_Exclude, mtInformation); }
    virtual void BroadcastChatFailure(const AString & a_Message, const cClientHandle * a_Exclude = nullptr) override { BroadcastChat(a_Message, a_Exclude, mtFailure); }
    virtual void BroadcastChatSuccess(const AString & a_Message, const cClientHandle * a_Exclude = nullptr) override { BroadcastChat(a_Message, a_Exclude, mtSuccess); }
    virtual void BroadcastChatWarning(const AString & a_Message, const cClientHandle * a_Exclude = nullptr) override { BroadcastChat(a_Message, a_Exclude, mtWarning); }
    virtual void BroadcastChatFatal  (const AString & a_Message, const cClientHandle * a_Exclude = nullptr) override { BroadcastChat(a_Message, a_Exclude, mtFailure); }
    virtual void BroadcastChatDeath  (const AString & a_Message, const cClientHandle * a_Exclude = nullptr) override { BroadcastChat(a_Message, a_Exclude, mtDeath); }
    virtual void BroadcastChat       (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = nullptr) override;
    // tolua_end

    virtual void BroadcastCollectEntity              (const cEntity & a_Pickup, const cPlayer & a_Player, int a_Count, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastDestroyEntity              (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastDetachEntity               (const cEntity & a_Entity, const cEntity & a_PreviousVehicle) override;
    virtual void BroadcastEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, int a_Duration, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityHeadLook             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityLook                 (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityMetadata             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityRelMove              (const cEntity & a_Entity, Vector3<Int8> a_RelMove, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityRelMoveLook          (const cEntity & a_Entity, Vector3<Int8> a_RelMove, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityStatus               (const cEntity & a_Entity, Int8 a_Status, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityVelocity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityAnimation            (const cEntity & a_Entity, Int8 a_Animation, const cClientHandle * a_Exclude = nullptr) override;  // tolua_export
    virtual void BroadcastLeashEntity                (const cEntity & a_Entity, const cEntity & a_EntityLeashedTo) override;
    virtual void BroadcastParticleEffect             (const AString & a_ParticleName, Vector3f a_Src, Vector3f a_Offset, float a_ParticleData, int a_ParticleAmount, const cClientHandle * a_Exclude = nullptr) override;  // Exported in ManualBindings_World.cpp
    virtual void BroadcastParticleEffect             (const AString & a_ParticleName, Vector3f a_Src, Vector3f a_Offset, float a_ParticleData, int a_ParticleAmount, std::array<int, 2> a_Data, const cClientHandle * a_Exclude = nullptr) override;  // Exported in ManualBindings_World.cpp
    virtual void BroadcastPlayerListAddPlayer        (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastPlayerListRemovePlayer     (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastPlayerListUpdateGameMode   (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastPlayerListUpdatePing       (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
    virtual void BroadcastScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
    virtual void BroadcastDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
    virtual void BroadcastSoundEffect                (const AString & a_SoundName, Vector3d a_Position, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = nullptr) override;  // Exported in ManualBindings_World.cpp
    virtual void BroadcastSoundParticleEffect        (const EffectID a_EffectID, Vector3i a_SrcPos, int a_Data, const cClientHandle * a_Exclude = nullptr) override;  // Exported in ManualBindings_World.cpp
    virtual void BroadcastSpawnEntity                (cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastTeleportEntity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastThunderbolt                (Vector3i a_BlockPos, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastTimeUpdate                 (const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastUnleashEntity              (const cEntity & a_Entity) override;
    virtual void BroadcastUseBed                     (const cEntity & a_Entity, Vector3i a_BlockPos) override;
    virtual void BroadcastWeather                    (eWeather a_Weather, const cClientHandle * a_Exclude = nullptr) override;

    virtual cBroadcastInterface & GetBroadcastManager(void) override
    {
        return *this;
    }

    void SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client);

    void MarkChunkDirty (int a_ChunkX, int a_ChunkZ);
    void MarkChunkSaving(int a_ChunkX, int a_ChunkZ);
    void MarkChunkSaved (int a_ChunkX, int a_ChunkZ);

    void QueueSetChunkData(cSetChunkDataPtr a_SetChunkData);

    void ChunkLighted(
        int a_ChunkX, int a_ChunkZ,
        const cChunkDef::BlockNibbles & a_BlockLight,
        const cChunkDef::BlockNibbles & a_SkyLight
    );

    bool GetChunkData(cChunkCoords a_Coords, cChunkDataCallback & a_Callback) const;

    bool GetChunkBlockTypes(int a_ChunkX, int a_ChunkZ, BLOCKTYPE * a_BlockTypes);

    bool IsChunkQueued(int a_ChunkX, int a_ChunkZ) const;

    bool IsChunkValid(int a_ChunkX, int a_ChunkZ) const;

    bool HasChunkAnyClients(int a_ChunkX, int a_ChunkZ) const;

    void QueueUnloadUnusedChunks(void);  // tolua_export

    void CollectPickupsByPlayer(cPlayer & a_Player);

    void AddPlayer(std::unique_ptr<cPlayer> a_Player, cWorld * a_OldWorld = nullptr);

    std::unique_ptr<cPlayer> RemovePlayer(cPlayer & a_Player, bool a_RemoveFromChunk);

#ifdef _DEBUG
    bool IsPlayerReferencedInWorldOrChunk(cPlayer & a_Player);
#endif

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

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

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

    bool DoWithNearestPlayer(Vector3d a_Pos, double a_RangeLimit, cPlayerListCallback a_Callback, bool a_CheckLineOfSight = true, bool a_IgnoreSpectator = true);

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

    void SendPlayerList(cPlayer * a_DestPlayer);  // Sends playerlist to the player

    void AddEntity(OwnedEntity a_Entity);

    bool HasEntity(UInt32 a_UniqueID);

    OwnedEntity RemoveEntity(cEntity & a_Entity);

    bool ForEachEntity(cEntityCallback a_Callback);  // Exported in ManualBindings.cpp

    bool ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback a_Callback);  // Exported in ManualBindings.cpp

    virtual bool ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback a_Callback) override;  // Exported in ManualBindings.cpp

    bool DoWithEntityByID(UInt32 a_UniqueID, cEntityCallback a_Callback);  // Exported in ManualBindings.cpp

    void CompareChunkClients(int a_ChunkX1, int a_ChunkZ1, int a_ChunkX2, int a_ChunkZ2, cClientDiffCallback & a_Callback);

    bool AddChunkClient(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);

    void RemoveChunkClient(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);

    void RemoveClientFromChunks(cClientHandle * a_Client);

    void SendChunkTo(int a_ChunkX, int a_ChunkZ, cChunkSender::eChunkPriority a_Priority, cClientHandle * a_Client);

    void ForceSendChunkTo(int a_ChunkX, int a_ChunkZ, cChunkSender::eChunkPriority a_Priority, cClientHandle * a_Client);

    void RemoveClientFromChunkSender(cClientHandle * a_Client);

    void TouchChunk(int a_ChunkX, int a_ChunkZ);

    void PrepareChunk(int a_ChunkX, int a_ChunkZ, std::unique_ptr<cChunkCoordCallback> a_CallAfter = {});

    void ChunkLoadFailed(int a_ChunkX, int a_ChunkZ);

    bool SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = nullptr);  // Exported in ManualBindings.cpp

    bool SetCommandBlockCommand(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Command);  // tolua_export

    bool IsTrapdoorOpen(int a_BlockX, int a_BlockY, int a_BlockZ);                                      // tolua_export

    bool SetTrapdoorOpen(int a_BlockX, int a_BlockY, int a_BlockZ, bool a_Open);                        // tolua_export

    void RegenerateChunk(int a_ChunkX, int a_ChunkZ);  // tolua_export

    void GenerateChunk(int a_ChunkX, int a_ChunkZ);  // tolua_export

    void QueueLightChunk(int a_ChunkX, int a_ChunkZ, std::unique_ptr<cChunkCoordCallback> a_Callback = {});

    bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);

    virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override;

    bool ForEachLoadedChunk(cFunctionRef<bool(int, int)> a_Callback);

    // tolua_begin

    void SetBlock(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);

    void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        return SetBlock({a_BlockX, a_BlockY, a_BlockZ}, a_BlockType, a_BlockMeta);
    }

    void FastSetBlock(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        m_ChunkMap->FastSetBlock(a_BlockPos, a_BlockType, a_BlockMeta);
    }

    void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        return FastSetBlock({a_BlockX, a_BlockY, a_BlockZ}, a_BlockType, a_BlockMeta);
    }

    BLOCKTYPE GetBlock(Vector3i a_BlockPos)
    {
        return m_ChunkMap->GetBlock(a_BlockPos);
    }

    BLOCKTYPE GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
    {
        return m_ChunkMap->GetBlock({a_BlockX, a_BlockY, a_BlockZ});
    }

    NIBBLETYPE GetBlockMeta(Vector3i a_BlockPos)
    {
        return m_ChunkMap->GetBlockMeta(a_BlockPos);
    }

    NIBBLETYPE GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
    {
        return m_ChunkMap->GetBlockMeta({a_BlockX, a_BlockY, a_BlockZ});
    }

    void SetBlockMeta(Vector3i a_BlockPos, NIBBLETYPE a_MetaData, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true);

    void SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true)
    {
        return SetBlockMeta({a_BlockX, a_BlockY, a_BlockZ}, a_MetaData, a_ShouldMarkDirty, a_ShouldInformClients);
    }

    NIBBLETYPE GetBlockSkyLight(Vector3i a_BlockPos);

    NIBBLETYPE GetBlockSkyLight(int a_BlockX, int a_BlockY, int a_BlockZ)
    {
        return GetBlockSkyLight({a_BlockX, a_BlockY, a_BlockZ});
    }

    NIBBLETYPE GetBlockBlockLight(Vector3i a_BlockPos);

    NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ)
    {
        return GetBlockBlockLight({a_BlockX, a_BlockY, a_BlockZ});
    }

    // tolua_end

    bool GetBlockTypeMeta(Vector3i a_BlockPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);

    bool GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
    {
        return GetBlockTypeMeta({a_BlockX, a_BlockY, a_BlockZ}, a_BlockType, a_BlockMeta);
    }

    bool GetBlockInfo(Vector3i a_BlockPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight);

    bool GetBlockInfo(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight)
    {
        return GetBlockInfo({a_BlockX, a_BlockY, a_BlockZ}, a_BlockType, a_Meta, a_SkyLight, a_BlockLight);
    }

    // TODO: NIBBLETYPE GetBlockActualLight(int a_BlockX, int a_BlockY, int a_BlockZ);

    virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) override;

    // tolua_begin

    void SpawnItemPickups(const cItems & a_Pickups, Vector3i a_BlockPos, double a_FlyAwaySpeed = 1.0, bool a_IsPlayerCreated = false);

    void SpawnItemPickups(const cItems & a_Pickups, Vector3d a_Pos, double a_FlyAwaySpeed = 1.0, bool a_IsPlayerCreated = false);

    virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed = 1.0, bool a_IsPlayerCreated = false) override
    {
        return SpawnItemPickups(a_Pickups, Vector3d{a_BlockX, a_BlockY, a_BlockZ}, a_FlyAwaySpeed, a_IsPlayerCreated);
    }

    void SpawnItemPickups(const cItems & a_Pickups, Vector3d a_Pos, Vector3d a_Speed, bool a_IsPlayerCreated = false);

    virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool a_IsPlayerCreated = false) override
    {
        return SpawnItemPickups(a_Pickups, {a_BlockX, a_BlockY, a_BlockZ}, {a_SpeedX, a_SpeedY, a_SpeedZ}, a_IsPlayerCreated);
    }

    UInt32 SpawnItemPickup(Vector3d a_Pos, const cItem & a_Item, Vector3f a_Speed, int a_LifetimeTicks = 6000, bool a_CanCombine = true);

    virtual UInt32 SpawnItemPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f, int a_LifetimeTicks = 6000, bool a_CanCombine = true) override
    {
        return SpawnItemPickup({a_PosX, a_PosY, a_PosZ}, a_Item, {a_SpeedX, a_SpeedY, a_SpeedZ}, a_LifetimeTicks, a_CanCombine);
    }

    UInt32 SpawnFallingBlock(Vector3i a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);

    UInt32 SpawnFallingBlock(int a_X, int a_Y, int a_Z, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        return SpawnFallingBlock({a_X, a_Y, a_Z}, a_BlockType, a_BlockMeta);
    }

    UInt32 SpawnMinecart(Vector3d a_Pos, int a_MinecartType, const cItem & a_Content = cItem(), int a_BlockHeight = 1);

    UInt32 SpawnMinecart(double a_X, double a_Y, double a_Z, int a_MinecartType, const cItem & a_Content = cItem(), int a_BlockHeight = 1)
    {
        return SpawnMinecart({a_X, a_Y, a_Z}, a_MinecartType, a_Content, a_BlockHeight);
    }

    // DEPRECATED, use the vector-parametered version instead.
    UInt32 SpawnBoat(double a_X, double a_Y, double a_Z, cBoat::eMaterial a_Material)
    {
        LOGWARNING("cWorld::SpawnBoat(double, double, double) is deprecated, use cWorld::SpawnBoat(Vector3d) instead.");
        return SpawnBoat({a_X, a_Y, a_Z}, a_Material);
    }

    UInt32 SpawnBoat(Vector3d a_Pos, cBoat::eMaterial a_Material);

    UInt32 SpawnExperienceOrb(Vector3d a_Pos, int a_Reward);

    virtual UInt32 SpawnExperienceOrb(double a_X, double a_Y, double a_Z, int a_Reward) override
    {
        return SpawnExperienceOrb({a_X, a_Y, a_Z}, a_Reward);
    }

    // tolua_end

    virtual std::vector<UInt32> SpawnSplitExperienceOrbs(Vector3d a_Pos, int a_Reward) override;  // Exported in ManualBindings_World.cpp

    std::vector<UInt32> SpawnSplitExperienceOrbs(double a_X, double a_Y, double a_Z, int a_Reward)
    {
        return SpawnSplitExperienceOrbs({a_X, a_Y, a_Z}, a_Reward);
    }

    // tolua_begin

    // DEPRECATED, use the vector-parametered version instead.
    UInt32 SpawnPrimedTNT(double a_X, double a_Y, double a_Z, int a_FuseTimeInSec = 80, double a_InitialVelocityCoeff = 1)
    {
        LOGWARNING("cWorld::SpawnPrimedTNT(double, double, double) is deprecated, use cWorld::SpawnPrimedTNT(Vector3d) instead.");
        return SpawnPrimedTNT({a_X, a_Y, a_Z}, a_FuseTimeInSec, a_InitialVelocityCoeff);
    }

    UInt32 SpawnPrimedTNT(Vector3d a_Pos, int a_FuseTimeInSec = 80, double a_InitialVelocityCoeff = 1);

    // tolua_end

    void SetBlocks(const sSetBlockVector & a_Blocks);

    void ReplaceBlocks(const sSetBlockVector & a_Blocks, BLOCKTYPE a_FilterBlockType);

    bool GetBlocks(sSetBlockVector & a_Blocks, bool a_ContinueOnFailure);

    // tolua_begin

    bool DigBlock(Vector3i a_BlockPos);

    bool DigBlock(int a_X, int a_Y, int a_Z)
    {
        return DigBlock({a_X, a_Y, a_Z});
    }

    bool DropBlockAsPickups(Vector3i a_BlockPos, const cEntity * a_Digger = nullptr, const cItem * a_Tool = nullptr);

    cItems PickupsFromBlock(Vector3i a_BlockPos, const cEntity * a_Digger = nullptr, const cItem * a_Tool = nullptr);

    virtual void SendBlockTo(int a_X, int a_Y, int a_Z, cPlayer & a_Player) override;

    bool SetSpawn(double a_X, double a_Y, double a_Z);

    double GetSpawnX(void) const { return m_SpawnX; }
    double GetSpawnY(void) const { return m_SpawnY; }
    double GetSpawnZ(void) const { return m_SpawnZ; }

    virtual void WakeUpSimulators(Vector3i a_Block) override;

    void WakeUpSimulatorsInArea(const cCuboid & a_Area);

    // DEPRECATED, use vector-parametered version instead
    void WakeUpSimulators(int a_BlockX, int a_BlockY, int a_BlockZ)
    {
        LOGWARNING("cWorld::WakeUpSimulators(int, int, int) is deprecated, use cWorld::WakeUpSimulators(Vector3i) instead.");
        WakeUpSimulators({a_BlockX, a_BlockY, a_BlockZ});
    }

    // DEPRECATED, use vector-parametered version instead
    void WakeUpSimulatorsInArea(int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ);

    // tolua_end

    inline cSimulatorManager * GetSimulatorManager(void) { return m_SimulatorManager.get(); }

    inline cFluidSimulator * GetWaterSimulator(void) { return m_WaterSimulator; }
    inline cFluidSimulator * GetLavaSimulator (void) { return m_LavaSimulator; }
    inline cRedstoneSimulator * GetRedstoneSimulator(void) { return m_RedstoneSimulator; }

    bool ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEntityCallback a_Callback);  // Exported in ManualBindings.cpp

    bool ForEachBrewingstandInChunk(int a_ChunkX, int a_ChunkZ, cBrewingstandCallback a_Callback);  // Exported in ManualBindings.cpp

    bool ForEachChestInChunk(int a_ChunkX, int a_ChunkZ, cChestCallback a_Callback);  // Exported in ManualBindings.cpp

    bool ForEachDispenserInChunk(int a_ChunkX, int a_ChunkZ, cDispenserCallback a_Callback);

    bool ForEachDropperInChunk(int a_ChunkX, int a_ChunkZ, cDropperCallback a_Callback);

    bool ForEachDropSpenserInChunk(int a_ChunkX, int a_ChunkZ, cDropSpenserCallback a_Callback);

    bool ForEachFurnaceInChunk(int a_ChunkX, int a_ChunkZ, cFurnaceCallback a_Callback);  // Exported in ManualBindings.cpp

    virtual void DoExplosionAt(double a_ExplosionSize, double a_BlockX, double a_BlockY, double a_BlockZ, bool a_CanCauseFire, eExplosionSource a_Source, void * a_SourceData) override;

    virtual bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback) override;  // Exported in ManualBindings.cpp

    bool DoWithBeaconAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconCallback a_Callback);  // Exported in ManualBindings.cpp

    virtual bool DoWithBedAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBedCallback a_Callback) override;  // Exported in ManualBindings.cpp

    bool DoWithBrewingstandAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBrewingstandCallback a_Callback);  // Lua-acessible

    bool DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback a_Callback);  // Exported in ManualBindings.cpp

    bool DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback a_Callback);  // Exported in ManualBindings.cpp

    bool GetSignLines (int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Exported in ManualBindings.cpp

    void UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) {m_ChunkMap->UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ); }  // tolua_export

    bool DoWithChunk(int a_ChunkX, int a_ChunkZ, cChunkCallback a_Callback);

    bool DoWithChunkAt(Vector3i a_BlockPos, cChunkCallback a_Callback);

    bool GrowTreeImage(const sSetBlockVector & a_Blocks);

    // tolua_begin

    bool GrowTree(int a_BlockX, int a_BlockY, int a_BlockZ);

    bool GrowTreeFromSapling(Vector3i a_BlockPos, NIBBLETYPE a_SaplingMeta)
    {
        // TODO: Change the implementation to use Vector3i, once cTree uses Vector3i-based functions
        return GrowTreeFromSapling(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, a_SaplingMeta);
    }

    bool GrowTreeFromSapling(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_SaplingMeta);

    bool GrowTreeByBiome(int a_BlockX, int a_BlockY, int a_BlockZ);

    int GrowPlantAt(Vector3i a_BlockPos, int a_NumStages = 1);

    bool GrowRipePlant(Vector3i a_BlockPos);

    bool GrowRipePlant(int a_BlockX, int a_BlockY, int a_BlockZ, bool a_IsByBonemeal = false)
    {
        UNUSED(a_IsByBonemeal);
        return GrowRipePlant({a_BlockX, a_BlockY, a_BlockZ});
    }

    int GrowCactus(int a_BlockX, int a_BlockY, int a_BlockZ, int a_NumBlocksToGrow);

    bool GrowMelonPumpkin(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType);

    int GrowSugarcane(int a_BlockX, int a_BlockY, int a_BlockZ, int a_NumBlocksToGrow);

    EMCSBiome GetBiomeAt(int a_BlockX, int a_BlockZ);

    bool SetBiomeAt(int a_BlockX, int a_BlockZ, EMCSBiome a_Biome);

    bool SetAreaBiome(int a_MinX, int a_MaxX, int a_MinZ, int a_MaxZ, EMCSBiome a_Biome);

    bool SetAreaBiome(const cCuboid & a_Area, EMCSBiome a_Biome);

    const AString & GetName(void) const { return m_WorldName; }

    const AString & GetDataPath(void) const { return m_DataPath; }

    const AString & GetIniFileName(void) const {return m_IniFileName; }

    cScoreboard & GetScoreBoard(void) { return m_Scoreboard; }

    cMapManager & GetMapManager(void) { return m_MapManager; }

    bool AreCommandBlocksEnabled(void) const { return m_bCommandBlocksEnabled; }
    void SetCommandBlocksEnabled(bool a_Flag) { m_bCommandBlocksEnabled = a_Flag; }

    eShrapnelLevel GetTNTShrapnelLevel(void) const { return m_TNTShrapnelLevel; }
    void SetTNTShrapnelLevel(eShrapnelLevel a_Flag) { m_TNTShrapnelLevel = a_Flag; }

    int GetMaxViewDistance(void) const { return m_MaxViewDistance; }
    void SetMaxViewDistance(int a_MaxViewDistance);

    bool ShouldUseChatPrefixes(void) const { return m_bUseChatPrefixes; }
    void SetShouldUseChatPrefixes(bool a_Flag) { m_bUseChatPrefixes = a_Flag; }

    bool ShouldBroadcastDeathMessages(void) const { return m_BroadcastDeathMessages; }
    bool ShouldBroadcastAchievementMessages(void) const { return m_BroadcastAchievementMessages; }


    AString GetLinkedNetherWorldName(void) const { return m_LinkedNetherWorldName; }
    void SetLinkedNetherWorldName(const AString & a_Name) { m_LinkedNetherWorldName = a_Name; }

    AString GetLinkedEndWorldName(void) const { return m_LinkedEndWorldName; }
    void SetLinkedEndWorldName(const AString & a_Name) { m_LinkedEndWorldName = a_Name; }

    AString GetLinkedOverworldName(void) const { return m_LinkedOverworldName; }
    void SetLinkedOverworldName(const AString & a_Name) { m_LinkedOverworldName = a_Name; }

    virtual int GetMinNetherPortalWidth(void) const override { return m_MinNetherPortalWidth; }
    virtual int GetMaxNetherPortalWidth(void) const override { return m_MaxNetherPortalWidth; }
    virtual void SetMinNetherPortalWidth(int a_NewMinWidth) override { m_MinNetherPortalWidth = a_NewMinWidth; }
    virtual void SetMaxNetherPortalWidth(int a_NewMaxWidth) override { m_MaxNetherPortalWidth = a_NewMaxWidth; }

    virtual int GetMinNetherPortalHeight(void) const override { return m_MinNetherPortalHeight; }
    virtual int GetMaxNetherPortalHeight(void) const override { return m_MaxNetherPortalHeight; }
    virtual void SetMinNetherPortalHeight(int a_NewMinHeight) override { m_MinNetherPortalHeight = a_NewMinHeight; }
    virtual void SetMaxNetherPortalHeight(int a_NewMaxHeight) override { m_MaxNetherPortalHeight = a_NewMaxHeight; }

    // tolua_end

    void SaveAllChunks(void);

    void QueueSaveAllChunks(void);  // tolua_export

    void QueueTask(std::function<void(cWorld &)> a_Task);  // Exported in ManualBindings.cpp

    void ScheduleTask(int a_DelayTicks, std::function<void(cWorld &)> a_Task);

    size_t GetNumChunks() const;  // tolua_export

    size_t GetNumUnusedDirtyChunks(void) const;  // tolua_export

    void GetChunkStats(int & a_NumValid, int & a_NumDirty, int & a_NumInLightingQueue);

    // Various queues length queries (cannot be const, they lock their CS):
    inline int GetGeneratorQueueLength     (void) { return m_Generator.GetQueueLength();   }    // tolua_export
    inline size_t GetLightingQueueLength   (void) { return m_Lighting.GetQueueLength();    }    // tolua_export
    inline size_t GetStorageLoadQueueLength(void) { return m_Storage.GetLoadQueueLength(); }    // tolua_export
    inline size_t GetStorageSaveQueueLength(void) { return m_Storage.GetSaveQueueLength(); }    // tolua_export

    cLightingThread & GetLightingThread(void) { return m_Lighting; }

    void InitializeSpawn(void);

    void Start();

    void Stop(cDeadlockDetect & a_DeadlockDetect);

    void TickQueuedBlocks(void);

    struct BlockTickQueueItem
    {
        int X;
        int Y;
        int Z;
        int TicksToWait;
    };

    void QueueBlockForTick(int a_BlockX, int a_BlockY, int a_BlockZ, int a_TicksToWait);  // tolua_export

    // tolua_begin
    void CastThunderbolt(Vector3i a_Block);
    void CastThunderbolt(int a_BlockX, int a_BlockY, int a_BlockZ);  // DEPRECATED, use vector-parametered version instead

    void SetWeather(eWeather a_NewWeather);

    void ChangeWeather(void);

    eWeather GetWeather(void) const { return m_Weather; }

    bool IsWeatherSunny(void) const { return (m_Weather == wSunny); }

    bool IsWeatherSunnyAt(int a_BlockX, int a_BlockZ)
    {
        return (IsWeatherSunny() || IsBiomeNoDownfall(GetBiomeAt(a_BlockX, a_BlockZ)));
    }

    bool IsWeatherRain(void) const { return (m_Weather == wRain); }

    bool IsWeatherRainAt(int a_BlockX, int a_BlockZ)
    {
        return (IsWeatherRain() && !IsBiomeNoDownfall(GetBiomeAt(a_BlockX, a_BlockZ)));
    }

    bool IsWeatherStorm(void) const { return (m_Weather == wStorm); }

    bool IsWeatherStormAt(int a_BlockX, int a_BlockZ)
    {
        return (IsWeatherStorm() && !IsBiomeNoDownfall(GetBiomeAt(a_BlockX, a_BlockZ)));
    }

    bool IsWeatherWet(void) const { return !IsWeatherSunny(); }

    virtual bool IsWeatherWetAt(int a_BlockX, int a_BlockZ) override
    {
        auto Biome = GetBiomeAt(a_BlockX, a_BlockZ);
        return (IsWeatherWet() && !IsBiomeNoDownfall(Biome) && !IsBiomeCold(Biome));
    }

    virtual bool IsWeatherWetAtXYZ(Vector3i a_Pos);

    int GetSeed(void) { return m_Generator.GetSeed(); }

    // tolua_end

    cChunkGeneratorThread & GetGenerator(void) { return m_Generator; }
    cWorldStorage &   GetStorage  (void) { return m_Storage; }
    cChunkMap *       GetChunkMap (void) { return m_ChunkMap.get(); }

    void SetNextBlockTick(int a_BlockX, int a_BlockY, int a_BlockZ);  // tolua_export

    int GetMaxSugarcaneHeight(void) const { return m_MaxSugarcaneHeight; }  // tolua_export
    int GetMaxCactusHeight   (void) const { return m_MaxCactusHeight; }     // tolua_export

    bool IsBlockDirectlyWatered(int a_BlockX, int a_BlockY, int a_BlockZ);  // tolua_export

    virtual UInt32 SpawnMob(double a_PosX, double a_PosY, double a_PosZ, eMonsterType a_MonsterType, bool a_Baby = false) override;  // tolua_export

    UInt32 SpawnMobFinalize(std::unique_ptr<cMonster> a_Monster);

    UInt32 CreateProjectile(Vector3d a_Pos, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem * a_Item, const Vector3d * a_Speed = nullptr);  // tolua_export

    UInt32 CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem * a_Item, const Vector3d * a_Speed = nullptr);  // tolua_export

    int GetTickRandomNumber(int a_Range);

    void TabCompleteUserName(const AString & a_Text, AStringVector & a_Results);

    NIBBLETYPE GetSkyDarkness() { return m_SkyDarkness; }

    void SetChunkAlwaysTicked(int a_ChunkX, int a_ChunkZ, bool a_AlwaysTicked = true);  // tolua_export

private:

    friend class cRoot;

    class cTickThread :
        public cIsThread
    {
        typedef cIsThread super;
    public:
        cTickThread(cWorld & a_World);

    protected:
        cWorld & m_World;

        // cIsThread overrides:
        virtual void Execute(void) override;
    } ;

    class cChunkGeneratorCallbacks :
        public cChunkGeneratorThread::cChunkSink,
        public cChunkGeneratorThread::cPluginInterface
    {
        cWorld * m_World;

        // cChunkSink overrides:
        virtual void OnChunkGenerated  (cChunkDesc & a_ChunkDesc) override;
        virtual bool IsChunkValid      (cChunkCoords a_Coords) override;
        virtual bool HasChunkAnyClients(cChunkCoords a_Coords) override;
        virtual bool IsChunkQueued     (cChunkCoords a_Coords) override;

        // cPluginInterface overrides:
        virtual void CallHookChunkGenerating(cChunkDesc & a_ChunkDesc) override;
        virtual void CallHookChunkGenerated (cChunkDesc & a_ChunkDesc) override;

    public:
        cChunkGeneratorCallbacks(cWorld & a_World);
    } ;


    size_t m_UnusedDirtyChunksCap;

    AString m_WorldName;

    AString m_DataPath;

    AString m_LinkedOverworldName;

    AString m_IniFileName;

    AString m_StorageSchema;

    int m_StorageCompressionFactor;

    std::atomic<bool> m_IsSavingEnabled;

    eDimension m_Dimension;

    bool m_IsSpawnExplicitlySet;
    double m_SpawnX;
    double m_SpawnY;
    double m_SpawnZ;

    // Variables defining the minimum and maximum size for a nether portal
    int m_MinNetherPortalWidth;
    int m_MaxNetherPortalWidth;
    int m_MinNetherPortalHeight;
    int m_MaxNetherPortalHeight;

    bool m_BroadcastDeathMessages;
    bool m_BroadcastAchievementMessages;

    bool   m_IsDaylightCycleEnabled;

    std::chrono::milliseconds m_WorldAge;

    std::chrono::milliseconds  m_TimeOfDay;
    cTickTimeLong  m_LastTimeUpdate;    // The tick in which the last time update has been sent.
    cTickTimeLong  m_LastChunkCheck;        // The last WorldAge (in ticks) in which unloading and possibly saving was triggered
    cTickTimeLong  m_LastSave;          // The last WorldAge (in ticks) in which save-all was triggerred
    std::map<cMonster::eFamily, cTickTimeLong> m_LastSpawnMonster;  // The last WorldAge (in ticks) in which a monster was spawned (for each megatype of monster)  // MG TODO : find a way to optimize without creating unmaintenability (if mob IDs are becoming unrowed)

    NIBBLETYPE m_SkyDarkness;

    eGameMode m_GameMode;
    bool m_bEnabledPVP;
    bool m_IsDeepSnowEnabled;
    bool m_ShouldLavaSpawnFire;
    bool m_VillagersShouldHarvestCrops;

    std::vector<BlockTickQueueItem *> m_BlockTickQueue;
    std::vector<BlockTickQueueItem *> m_BlockTickQueueCopy;  // Second is for safely removing the objects from the queue

    std::unique_ptr<cSimulatorManager>   m_SimulatorManager;
    std::unique_ptr<cSandSimulator>      m_SandSimulator;
    cFluidSimulator *                    m_WaterSimulator;
    cFluidSimulator *                    m_LavaSimulator;
    std::unique_ptr<cFireSimulator>      m_FireSimulator;
    cRedstoneSimulator * m_RedstoneSimulator;

    cCriticalSection m_CSPlayers;
    cPlayerList      m_Players;

    cWorldStorage    m_Storage;

    unsigned int m_MaxPlayers;

    std::unique_ptr<cChunkMap> m_ChunkMap;

    bool m_bAnimals;
    std::set<eMonsterType> m_AllowedMobs;

    eWeather m_Weather;
    int m_WeatherInterval;
    int m_MaxSunnyTicks, m_MinSunnyTicks;
    int m_MaxRainTicks,  m_MinRainTicks;
    int m_MaxThunderStormTicks, m_MinThunderStormTicks;

    int  m_MaxCactusHeight;
    int  m_MaxSugarcaneHeight;
    bool m_IsBeetrootsBonemealable;
    bool m_IsCactusBonemealable;
    bool m_IsCarrotsBonemealable;
    bool m_IsCropsBonemealable;
    bool m_IsGrassBonemealable;
    bool m_IsMelonStemBonemealable;
    bool m_IsMelonBonemealable;
    bool m_IsPotatoesBonemealable;
    bool m_IsPumpkinStemBonemealable;
    bool m_IsPumpkinBonemealable;
    bool m_IsSaplingBonemealable;
    bool m_IsSugarcaneBonemealable;
    bool m_IsBigFlowerBonemealable;
    bool m_IsTallGrassBonemealable;

    bool m_bCommandBlocksEnabled;

    bool m_bUseChatPrefixes;

    eShrapnelLevel m_TNTShrapnelLevel;

    int m_MaxViewDistance;

    AString m_LinkedNetherWorldName;

    AString m_LinkedEndWorldName;

    cChunkGeneratorThread m_Generator;

    cScoreboard      m_Scoreboard;
    cMapManager      m_MapManager;

    cChunkGeneratorCallbacks m_GeneratorCallbacks;

    cChunkSender     m_ChunkSender;
    cLightingThread  m_Lighting;
    cTickThread      m_TickThread;

    cCriticalSection m_CSTasks;

    std::vector<std::pair<Int64, std::function<void(cWorld &)>>> m_Tasks;

    cCriticalSection  m_CSClients;

    cClientHandlePtrs m_Clients;

    cClientHandles m_ClientsToRemove;

    cClientHandlePtrs m_ClientsToAdd;

    cCriticalSection m_CSEntitiesToAdd;

    cEntityList m_EntitiesToAdd;

    cCriticalSection m_CSPlayersToAdd;

    cAwaitingPlayerList m_PlayersToAdd;

    cCriticalSection m_CSSetChunkDataQueue;

    cSetChunkDataPtrs m_SetChunkDataQueue;

    cWorld(
        const AString & a_WorldName, const AString & a_DataPath,
        cDeadlockDetect & a_DeadlockDetect, const AStringVector & a_WorldNames,
        eDimension a_Dimension = dimOverworld, const AString & a_LinkedOverworldName = {}
    );
    virtual ~cWorld() override;

    void Tick(std::chrono::milliseconds a_Dt, std::chrono::milliseconds a_LastTickDurationMSec);

    void TickWeather(float a_Dt);

    void TickMobs(std::chrono::milliseconds a_Dt);

    void TickQueuedTasks(void);

    void TickClients(float a_Dt);

    void UnloadUnusedChunks(void);

    void UpdateSkyDarkness(void);

    void GenerateRandomSpawn(int a_MaxSpawnRadius);

    bool CanSpawnAt(double a_X, double & a_Y, double a_Z);

    bool CheckPlayerSpawnPoint(int a_PosX, int a_PosY, int a_PosZ);

    eWeather ChooseNewWeather(void);

    cFluidSimulator * InitializeFluidSimulator(cIniFile & a_IniFile, const char * a_FluidName, BLOCKTYPE a_SimulateBlock, BLOCKTYPE a_StationaryBlock);

    cRedstoneSimulator * InitializeRedstoneSimulator(cIniFile & a_IniFile);

    void AddQueuedPlayers(void);

    void InitializeAndLoadMobSpawningValues(cIniFile & a_IniFile);

    void SetChunkData(cSetChunkData & a_SetChunkData);

    bool GetLargeTreeAdjustment(int & a_BlockX, int & a_BlockY, int & a_BlockZ, NIBBLETYPE a_SaplingMeta);
};  // tolua_export