Chunk.h

Go to the documentation of this file.

 
#pragma once
 
#include "BlockEntities/BlockEntity.h"
#include "ChunkData.h"
 
#include "Simulator/FireSimulator.h"
#include "Simulator/SandSimulator.h"
 
#include "ChunkMap.h"
 
 
 
 
 
class cWorld;
class cClientHandle;
class cPlayer;
class cChunkMap;
class cBoundingBox;
class cChunkDataCallback;
class cBlockArea;
class cBlockArea;
class cFluidSimulatorData;
class cMobCensus;
class cMobSpawner;
class cRedstoneSimulatorChunkData;
 
struct SetChunkData;
 
// A convenience macro for calling GetChunkAndRelByAbsolute.
#define PREPARE_REL_AND_CHUNK(Position, OriginalChunk) cChunk * Chunk; Vector3i Rel; bool RelSuccess = (OriginalChunk).GetChunkAndRelByAbsolute(Position, &Chunk, Rel)
 
 
class cChunk
{
public:
 
    enum ePresence
    {
        cpInvalid,  
        cpQueued,   
        cpPresent,  
    };
 
    cChunk(
        int a_ChunkX, int a_ChunkZ,   // Chunk coords
        cChunkMap * a_ChunkMap, cWorld * a_World   // Parent objects
    );
    cChunk(const cChunk & Other) = delete;
    ~cChunk();
 
    void BroadcastPendingChanges(void);
 
    bool IsValid(void) const {return (m_Presence == cpPresent); }
 
    bool IsQueued(void) const {return (m_Presence == cpQueued); }
 
    void SetPresence(ePresence a_Presence);
 
    void MarkRegenerating(void);
 
    bool IsDirty(void) const {return m_IsDirty; }
 
    bool CanUnload(void) const;
 
    bool CanUnloadAfterSaving(void) const;
 
    void OnUnload();
 
    bool IsLightValid(void) const {return m_IsLightValid; }
 
    /*
    To save a chunk, the WSSchema must:
    1. Mark the chunk as being saved (MarkSaving())
    2. Get the chunk's data using GetAllData()
    3. Mark the chunk as saved (MarkSaved())
    If anywhere inside this sequence another thread mmodifies the chunk, the chunk will not get marked as saved in MarkSaved()
    */
    void MarkSaving(void);  // Marks the chunk as being saved.
    void MarkSaved(void);  // Marks the chunk as saved, if it didn't change from the last call to MarkSaving()
    void MarkLoaded(void);  // Marks the chunk as freshly loaded. Fails if the chunk is already valid
 
    void MarkLoadFailed(void);
 
    void GetAllData(cChunkDataCallback & a_Callback) const;
 
    void SetAllData(SetChunkData && a_SetChunkData);
 
    void SetLight(
        const cChunkDef::BlockNibbles & a_BlockLight,
        const cChunkDef::BlockNibbles & a_SkyLight
    );
 
    void WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes);
 
    void Stay(bool a_Stay = true);
 
    void CollectMobCensus(cMobCensus & toFill);
 
    void SpawnMobs(cMobSpawner & a_MobSpawner);
 
    void Tick(std::chrono::milliseconds a_Dt);
 
    void TickBlock(const Vector3i a_RelPos);
 
    int GetPosX(void) const { return m_PosX; }
    int GetPosZ(void) const { return m_PosZ; }
    cChunkCoords GetPos() const { return {m_PosX, m_PosZ}; }
 
    cWorld * GetWorld(void) const { return m_World; }
 
    void SetBlock(Vector3i a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
    // SetBlock() does a lot of work (heightmap, tickblocks, blockentities) so a BlockIdx version doesn't make sense
 
    void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta);  // Doesn't force block updates on neighbors, use for simple changes such as grass growing etc.
    void FastSetBlock(Vector3i a_RelPos, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta)
    {
        FastSetBlock(a_RelPos.x, a_RelPos.y, a_RelPos.z, a_BlockType, a_BlockMeta);
    }
 
    BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const { return m_BlockData.GetBlock({ a_RelX, a_RelY, a_RelZ }); }
    BLOCKTYPE GetBlock(Vector3i a_RelCoords) const { return m_BlockData.GetBlock(a_RelCoords); }
 
    void GetBlockTypeMeta(Vector3i a_RelPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
    void GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const
    {
        GetBlockTypeMeta({ a_RelX, a_RelY, a_RelZ }, a_BlockType, a_BlockMeta);
    }
 
    void GetBlockInfo(Vector3i a_RelPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight) const;
 
    bool GetChunkAndRelByAbsolute(const Vector3d & a_Position, cChunk ** a_Chunk, Vector3i & a_Rel);
 
    bool GetChunkAndRelByAbsolute(const Vector3i & a_Position, cChunk ** a_Chunk, Vector3i & a_Rel);
 
    cChunk * GetNeighborChunk(int a_BlockX, int a_BlockZ);
 
    cChunk * GetRelNeighborChunk(int a_RelX, int a_RelZ);
 
    cChunk * GetRelNeighborChunkAdjustCoords(Vector3i & a_RelPos) const;
 
    EMCSBiome GetBiomeAt(int a_RelX, int a_RelZ) const {return cChunkDef::GetBiome(m_BiomeMap, a_RelX, a_RelZ); }
 
    void SetBiomeAt(int a_RelX, int a_RelZ, EMCSBiome a_Biome);
 
    void SetAreaBiome(int a_MinRelX, int a_MaxRelX, int a_MinRelZ, int a_MaxRelZ, EMCSBiome a_Biome);
 
    int GetHeight( int a_X, int a_Z) const;
 
    bool IsWeatherSunnyAt(int a_RelX, int a_RelZ) const;
 
    bool IsWeatherWetAt(int a_RelX, int a_RelZ) const;
 
    bool IsWeatherWetAt(Vector3i a_Position) const;
 
    void SendBlockTo(int a_RelX, int a_RelY, int a_RelZ, cClientHandle * a_Client);
 
    bool AddClient(cClientHandle * a_Client);
 
    void RemoveClient(cClientHandle * a_Client);
 
    bool HasClient(cClientHandle * a_Client);
 
    bool HasAnyClients(void) const;
 
    void AddEntity(OwnedEntity a_Entity);
 
    OwnedEntity RemoveEntity(cEntity & a_Entity);
 
    bool HasEntity(UInt32 a_EntityID) const;
 
    bool ForEachEntity(cEntityCallback a_Callback) const;  // Lua-accessible
 
    bool ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback a_Callback) const;  // Lua-accessible
 
    bool DoWithEntityByID(UInt32 a_EntityID, cEntityCallback a_Callback, bool & a_CallbackResult) const;  // Lua-accessible
 
    bool ForEachBlockEntity(cBlockEntityCallback a_Callback);  // Lua-accessible
 
    bool DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback);  // Lua-acessible
 
    bool UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z);  // [x, y, z] in world block coords
 
    void SendBlockEntity             (int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client);
 
    Vector3i PositionToWorldPosition(Vector3i a_RelPos)
    {
        return PositionToWorldPosition(a_RelPos.x, a_RelPos.y, a_RelPos.z);
    }
 
    void     PositionToWorldPosition(int a_RelX, int a_RelY, int a_RelZ, int & a_BlockX, int & a_BlockY, int & a_BlockZ);
    Vector3i PositionToWorldPosition(int a_RelX, int a_RelY, int a_RelZ);
 
    inline void MarkDirty(void)
    {
        m_IsDirty = true;
        m_IsSaving = false;
    }
 
    inline void SetNextBlockToTick(const Vector3i a_RelPos)
    {
        m_BlockToTick = a_RelPos;
    }
 
    inline NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
    {
        return m_BlockData.GetMeta({ a_RelX, a_RelY, a_RelZ });
    }
 
    NIBBLETYPE GetMeta(Vector3i a_RelPos) const { return m_BlockData.GetMeta(a_RelPos); }
 
    void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Meta)
    {
        SetMeta({ a_RelX, a_RelY, a_RelZ }, a_Meta);
    }
 
    inline void SetMeta(Vector3i a_RelPos, NIBBLETYPE a_Meta)
    {
        m_BlockData.SetMeta(a_RelPos, a_Meta);
        MarkDirty();
        m_PendingSendBlocks.emplace_back(m_PosX, m_PosZ, a_RelPos.x, a_RelPos.y, a_RelPos.z, GetBlock(a_RelPos), a_Meta);
    }
 
    NIBBLETYPE GetTimeAlteredLight(NIBBLETYPE a_Skylight) const;
 
    inline NIBBLETYPE GetBlockLight(Vector3i a_RelPos) const { return m_LightData.GetBlockLight(a_RelPos); }
    inline NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const { return m_LightData.GetBlockLight({ a_RelX, a_RelY, a_RelZ }); }
 
    inline NIBBLETYPE GetSkyLight(Vector3i a_RelPos) const { return m_LightData.GetSkyLight(a_RelPos); }
    inline NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const { return m_LightData.GetSkyLight({ a_RelX, a_RelY, a_RelZ }); }
 
    inline NIBBLETYPE GetSkyLightAltered(Vector3i a_RelPos) const { return GetTimeAlteredLight(m_LightData.GetSkyLight(a_RelPos)); }
    inline NIBBLETYPE GetSkyLightAltered(int a_RelX, int a_RelY, int a_RelZ) const { return GetSkyLightAltered({ a_RelX, a_RelY, a_RelZ }); }
 
    bool UnboundedRelGetBlock(Vector3i a_RelCoords, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 
    bool UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const
    {
        return UnboundedRelGetBlock({a_RelX, a_RelY, a_RelZ}, a_BlockType, a_BlockMeta);
    }
 
    bool UnboundedRelGetBlockType(Vector3i a_RelCoords, BLOCKTYPE & a_BlockType) const;
 
    bool UnboundedRelGetBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType) const
    {
        return UnboundedRelGetBlockType({a_RelX, a_RelY, a_RelZ}, a_BlockType);
    }
 
    bool UnboundedRelGetBlockMeta(Vector3i a_RelPos, NIBBLETYPE & a_BlockMeta) const;
 
    bool UnboundedRelGetBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockMeta) const
    {
        return UnboundedRelGetBlockMeta({a_RelX, a_RelY, a_RelZ}, a_BlockMeta);
    }
 
    bool UnboundedRelGetBlockBlockLight(Vector3i a_RelPos, NIBBLETYPE & a_BlockLight) const;
 
    bool UnboundedRelGetBlockBlockLight(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockLight) const
    {
        return UnboundedRelGetBlockBlockLight({a_RelX, a_RelY, a_RelZ}, a_BlockLight);
    }
 
    bool UnboundedRelGetBlockSkyLight(Vector3i a_RelPos, NIBBLETYPE & a_SkyLight) const;
 
    bool UnboundedRelGetBlockSkyLight(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_SkyLight) const
    {
        return UnboundedRelGetBlockSkyLight({a_RelX, a_RelY, a_RelZ}, a_SkyLight);
    }
 
    bool UnboundedRelGetBlockLights(Vector3i a_RelPos, NIBBLETYPE & a_BlockLight, NIBBLETYPE & a_SkyLight) const;
 
    bool UnboundedRelGetBlockLights(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockLight, NIBBLETYPE & a_SkyLight) const
    {
        return UnboundedRelGetBlockLights({a_RelX, a_RelY, a_RelZ}, a_BlockLight, a_SkyLight);
    }
 
    bool UnboundedRelSetBlock(Vector3i a_RelPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
    bool UnboundedRelSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        return UnboundedRelSetBlock({a_RelX, a_RelY, a_RelZ}, a_BlockType, a_BlockMeta);
    }
 
    bool UnboundedRelFastSetBlock(Vector3i a_RelPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
    bool UnboundedRelFastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
    {
        return UnboundedRelFastSetBlock({a_RelX, a_RelY, a_RelZ}, a_BlockType, a_BlockMeta);
    }
 
 
 
    // Per-chunk simulator data:
    cFireSimulatorChunkData & GetFireSimulatorData (void) { return m_FireSimulatorData; }
    cFluidSimulatorData * GetWaterSimulatorData(void) const { return m_WaterSimulatorData; }
    cFluidSimulatorData * GetLavaSimulatorData (void) const { return m_LavaSimulatorData; }
    cSandSimulatorChunkData & GetSandSimulatorData (void) { return m_SandSimulatorData; }
    cRedstoneSimulatorChunkData * GetRedstoneSimulatorData(void) const { return m_RedstoneSimulatorData; }
 
    cBlockEntity * GetBlockEntity(Vector3i a_AbsPos);
 
    cBlockEntity * GetBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ) { return GetBlockEntity({a_BlockX, a_BlockY, a_BlockZ}); }
 
    cBlockEntity * GetBlockEntityRel(Vector3i a_RelPos);
 
    bool ShouldBeTicked(void) const;
 
    void SetAlwaysTicked(bool a_AlwaysTicked);
 
    const auto & GetAllClients(void) const
    {
        return m_LoadedByClient;
    }
 
    Vector3i RelativeToAbsolute(Vector3i a_RelBlockPosition) const
    {
        return cChunkDef::RelativeToAbsolute(a_RelBlockPosition, {m_PosX, m_PosZ});
    }
 
    bool IsSlimeChunk() const;
 
private:
 
    friend class cChunkMap;
 
    struct sSetBlockQueueItem
    {
        Int64 m_Tick;
        int m_RelX, m_RelY, m_RelZ;
        BLOCKTYPE m_BlockType;
        NIBBLETYPE m_BlockMeta;
        BLOCKTYPE m_PreviousType;
 
        sSetBlockQueueItem(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, Int64 a_Tick, BLOCKTYPE a_PreviousBlockType) :
            m_Tick(a_Tick), m_RelX(a_RelX), m_RelY(a_RelY), m_RelZ(a_RelZ), m_BlockType(a_BlockType), m_BlockMeta(a_BlockMeta), m_PreviousType(a_PreviousBlockType)
        {
        }
    } ;
 
    typedef std::vector<sSetBlockQueueItem> sSetBlockQueueVector;
 
 
    ePresence m_Presence;
 
    bool m_IsLightValid;   // True if the blocklight and skylight are calculated
    bool m_IsDirty;        // True if the chunk has changed since it was last saved
    bool m_IsSaving;       // True if the chunk is being saved
 
    sSetBlockVector m_PendingSendBlocks;
 
    std::vector<cBlockEntity *> m_PendingSendBlockEntities;
 
    std::queue<Vector3i> m_BlocksToCheck;
 
    // A critical section is not needed, because all chunk access is protected by its parent ChunkMap's csLayers
    std::vector<cClientHandle *> m_LoadedByClient;
    std::vector<OwnedEntity> m_Entities;
    cBlockEntities m_BlockEntities;
 
    unsigned m_StayCount;
 
    int m_PosX, m_PosZ;
    cWorld *    m_World;
    cChunkMap * m_ChunkMap;
 
    ChunkBlockData m_BlockData;
    ChunkLightData m_LightData;
 
    cChunkDef::HeightMap m_HeightMap;
    cChunkDef::BiomeMap  m_BiomeMap;
 
    Vector3i m_BlockToTick;
 
    cChunk * m_NeighborXM;  // Neighbor at [X - 1, Z]
    cChunk * m_NeighborXP;  // Neighbor at [X + 1, Z]
    cChunk * m_NeighborZM;  // Neighbor at [X,     Z - 1]
    cChunk * m_NeighborZP;  // Neighbor at [X,     Z + 1]
 
    // Per-chunk simulator data:
    cFireSimulatorChunkData m_FireSimulatorData;
    cFluidSimulatorData *   m_WaterSimulatorData;
    cFluidSimulatorData *   m_LavaSimulatorData;
    cSandSimulatorChunkData m_SandSimulatorData;
    cRedstoneSimulatorChunkData * m_RedstoneSimulatorData;
 
    unsigned m_AlwaysTicked;
 
    // Pick up a random block of this chunk
    void GetRandomBlockCoords(int & a_X, int & a_Y, int & a_Z);
    void GetThreeRandomNumbers(int & a_X, int & a_Y, int & a_Z, int a_MaxX, int a_MaxY, int a_MaxZ);
 
    void AddBlockEntity(OwnedBlockEntity a_BlockEntity);
 
    void WakeUpSimulators(void);
 
    void CheckBlocks();
 
    void TickBlocks(void);
 
    void ApplyWeatherToTop(void);
 
    cItems PickupsFromBlock(Vector3i a_RelPos, const cEntity * a_Digger, const cItem * a_Tool);
 
    int GrowPlantAt(Vector3i a_RelPos, int a_NumStages = 1);
 
    void MoveEntityToNewChunk(OwnedEntity a_Entity);
 
    bool HasPlayerEntities() const;
};