World.h

Go to the documentation of this file.

 
#pragma once
 
#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;
class cEntity;
class cChunkGenerator;  // The thread responsible for generating chunks
class cCuboid;
class cCompositeChat;
class cDeadlockDetect;
class cUUID;
 
struct SetChunkData;
 
 
 
 
 
class cWorld  // tolua_export
    final:
    public cForEachChunkProvider,
    public cWorldInterface,
    public cBroadcastInterface
// tolua_begin
{
public:
    // tolua_end
 
    class cLock:
        public cCSLock
    {
        using Super = cCSLock;
    public:
        cLock(const cWorld & a_World);
    };
 
    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;
 
    // 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();
    }
 
    void SetTicksUntilWeatherChange(int a_WeatherInterval)
    {
        m_WeatherInterval = a_WeatherInterval;
    }
 
    int GetDefaultWeatherInterval(eWeather a_Weather) const;
 
    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 IsFarmlandTramplingEnabled(void) const { return m_bFarmlandTramplingEnabled; }
 
    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
 
    virtual cTickTime GetTimeOfDay(void) const override;
    virtual cTickTimeLong GetWorldAge(void) const override;
    cTickTimeLong GetWorldDate() const;
    cTickTimeLong GetWorldTickAge() const;
 
    virtual void SetTimeOfDay(cTickTime a_TimeOfDay) override;
 
    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;  
    virtual void BroadcastBossBarUpdateHealth(const cEntity & a_Entity, UInt32 a_UniqueID, float a_FractionFilled) 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_Collected, const cEntity & a_Collector, unsigned 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 BroadcastEntityPosition             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    void         BroadcastEntityProperties           (const cEntity & a_Entity);
    virtual void BroadcastEntityVelocity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastEntityAnimation            (const cEntity & a_Entity, EntityAnimation 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 BroadcastPlayerListHeaderFooter     (const cCompositeChat & a_Header, const cCompositeChat & a_Footer) override;  // tolua_export
    virtual void BroadcastPlayerListRemovePlayer     (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 BroadcastPlayerListUpdateGameMode   (const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr) override;
    virtual void BroadcastPlayerListUpdatePing       () 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 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 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(SetChunkData && 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 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 CollectPickupsByEntity(cEntity & a_Entity);
 
    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, cWorld * a_OldWorld = nullptr);
 
    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
 
    size_t GetPlayerCount() const;
 
    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::Priority a_Priority, cClientHandle * a_Client);
 
    void ForceSendChunkTo(int a_ChunkX, int a_ChunkZ, cChunkSender::Priority a_Priority, cClientHandle * a_Client);
 
    void PrepareChunk(int a_ChunkX, int a_ChunkZ, std::unique_ptr<cChunkCoordCallback> a_CallAfter = {});
 
    void ChunkLoadFailed(int a_ChunkX, int a_ChunkZ);
 
    bool SetSignLines(Vector3i a_BlockPos, 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 SetCommandBlockCommand(Vector3i a_BlockPos, const AString & a_Command)
    {
        return SetCommandBlockCommand(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, a_Command);
    }
 
    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);
 
    void SetBlock(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
    void FastSetBlock(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        m_ChunkMap.FastSetBlock(a_BlockPos, a_BlockType, a_BlockMeta);
    }
 
    BLOCKTYPE GetBlock(Vector3i a_BlockPos) const
    {
        return m_ChunkMap.GetBlock(a_BlockPos);
    }
 
    NIBBLETYPE GetBlockMeta(Vector3i a_BlockPos) const
    {
        return m_ChunkMap.GetBlockMeta(a_BlockPos);
    }
 
    void SetBlockMeta(Vector3i a_BlockPos, NIBBLETYPE a_MetaData);
 
    NIBBLETYPE GetBlockSkyLight(Vector3i a_BlockPos) const;
 
    NIBBLETYPE GetBlockBlockLight(Vector3i a_BlockPos) const;
 
    bool GetBlockTypeMeta(Vector3i a_BlockPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 
    bool GetBlockInfo(Vector3i a_BlockPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight) const;
 
    // 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(Vector3d a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
    UInt32 SpawnFallingBlock(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        // When creating from a block position (Vector3i), move the spawn point to the middle of the block by adding (0.5, 0, 0.5)
        return SpawnFallingBlock(Vector3d(0.5, 0, 0.5) + a_BlockPos, a_BlockType, a_BlockMeta);
    }
 
    UInt32 SpawnFallingBlock(int a_X, int a_Y, int a_Z, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        return SpawnFallingBlock(Vector3i{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, bool a_ShouldPlayFuseSound = true)
    {
        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, a_ShouldPlayFuseSound);
    }
 
    UInt32 SpawnPrimedTNT(Vector3d a_Pos, int a_FuseTimeInSec = 80, double a_InitialVelocityCoeff = 1, bool a_ShouldPlayFuseSound = true);
 
    UInt32 SpawnEnderCrystal(Vector3d a_Pos, bool a_ShowBottom);
 
    // tolua_end
 
    void PlaceBlock(const Vector3i a_Position, const BLOCKTYPE a_BlockType, const NIBBLETYPE a_BlockMeta);
 
    bool GetBlocks(sSetBlockVector & a_Blocks, bool a_ContinueOnFailure);
 
    using cWorldInterface::SendBlockTo;
 
    // tolua_begin
 
    bool DigBlock(Vector3i a_BlockPos, const cEntity * a_Digger = nullptr);
 
    bool DigBlock(int a_X, int a_Y, int a_Z, cEntity * a_Digger = nullptr)
    {
        return DigBlock({a_X, a_Y, a_Z}, a_Digger);
    }
 
    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, const cPlayer & a_Player) override;
 
    bool SetSpawn(int a_X, int a_Y, int a_Z);
 
    int GetSpawnX(void) const { return m_SpawnX; }
    int GetSpawnY(void) const { return m_SpawnY; }
    int GetSpawnZ(void) const { return m_SpawnZ; }
 
    virtual void WakeUpSimulators(Vector3i a_Block) override;
 
    void WakeUpSimulatorsInArea(const cCuboid & a_Area);
 
    // 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
 
    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(Vector3i a_Position, cBlockEntityCallback a_Callback) override;  // 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);
 
    bool GrowTree(Vector3i a_BlockPos);
 
    bool GrowTreeFromSapling(Vector3i a_BlockPos);
 
    bool GrowTreeByBiome(Vector3i a_BlockPos);
 
    // tolua_begin
 
    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);
        LOGWARNING("Warning: cWorld:GrowRipePlant function expects Vector3i-based coords rather than int-based coords. Emulating old-style call.");
        return GrowRipePlant({ a_BlockX, a_BlockY, a_BlockZ });
    }
 
    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(cTickTime 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 size_t 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) const;
 
    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;
 
    virtual bool IsWeatherWetAtXYZ(Vector3i a_Position) override;
 
    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; }
 
    void SetNextBlockToTick(const Vector3i a_BlockPos);  // 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:
 
    class cTickThread:
        public cIsThread
    {
        using Super = cIsThread;
 
    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;
    int m_SpawnX;
    int m_SpawnY;
    int 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_WorldDate;
 
    cTickTimeLong m_WorldTickAge;
 
    std::chrono::milliseconds m_LastChunkCheck;  // The last WorldAge in which unloading and possibly saving was triggered.
    std::chrono::milliseconds m_LastSave;  // The last WorldAge 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_bFarmlandTramplingEnabled;
    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;
 
    // Protect with chunk map CS
    std::vector<cPlayer *> m_Players;
 
    cWorldStorage m_Storage;
 
    unsigned int m_MaxPlayers;
 
    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;
    /* TODO: Enable when functionality exists again
    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<std::chrono::milliseconds, std::function<void(cWorld &)>>> m_Tasks;
 
    cCriticalSection m_CSEntitiesToAdd;
 
    std::vector<std::pair<OwnedEntity, cWorld *>> m_EntitiesToAdd;
 
    cCriticalSection m_CSSetChunkDataQueue;
 
    std::vector<SetChunkData> m_SetChunkDataQueue;
 
    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 TickQueuedChunkDataSets();
 
    void TickQueuedEntityAdditions(void);
 
    void TickQueuedTasks(void);
 
    void UnloadUnusedChunks(void);
 
    void UpdateSkyDarkness(void);
 
    void GenerateRandomSpawn(int a_MaxSpawnRadius);
 
    bool CanSpawnAt(int a_X, int & a_Y, int a_Z);
 
    bool CheckPlayerSpawnPoint(int a_PosX, int a_PosY, int a_PosZ)
    {
        return CheckPlayerSpawnPoint({a_PosX, a_PosY, a_PosZ});
    }
    bool CheckPlayerSpawnPoint(Vector3i a_Pos);
 
    eWeather ChooseNewWeather(void);
 
    cFluidSimulator * InitializeFluidSimulator(cIniFile & a_IniFile, const char * a_FluidName, BLOCKTYPE a_SimulateBlock, BLOCKTYPE a_StationaryBlock);
 
    cRedstoneSimulator * InitializeRedstoneSimulator(cIniFile & a_IniFile);
 
    void InitializeAndLoadMobSpawningValues(cIniFile & a_IniFile);
 
    bool GetLargeTreeAdjustment(Vector3i & a_BlockPos, NIBBLETYPE a_SaplingMeta);
};  // tolua_export