Chunk.h

Go to the documentation of this file.

#pragma once

#include "Entities/Entity.h"
#include "ChunkData.h"

#include "Simulator/FireSimulator.h"
#include "Simulator/SandSimulator.h"
#include "Simulator/RedstoneSimulator.h"

#include "ChunkMap.h"





class cWorld;
class cClientHandle;
class cPlayer;
class cChunkMap;
class cBeaconEntity;
class cBedEntity;
class cBrewingstandEntity;
class cBoundingBox;
class cChestEntity;
class cChunkDataCallback;
class cCommandBlockEntity;
class cDispenserEntity;
class cFurnaceEntity;
class cNoteEntity;
class cMobHeadEntity;
class cFlowerPotEntity;
class cBlockArea;
class cBlockArea;
class cFluidSimulatorData;
class cMobCensus;
class cMobSpawner;
class cSetChunkData;

typedef std::list<cClientHandle *>                cClientHandleList;

// A convenience macro for calling GetChunkAndRelByAbsolute.
#define PREPARE_REL_AND_CHUNK(Position, OriginalChunk) cChunk * Chunk; Vector3i Rel; bool RelSuccess = (OriginalChunk).GetChunkAndRelByAbsolute(Position, &Chunk, Rel)
#define PREPARE_BLOCKDATA BLOCKTYPE BlockType; NIBBLETYPE BlockMeta;


// This class is not to be used directly
// Instead, call actions on cChunkMap (such as cChunkMap::SetBlock() etc.)
class cChunk :
    public cChunkDef  // The inheritance is "misused" here only to inherit the functions and constants defined in cChunkDef
{
public:

    enum ePresence
    {
        cpInvalid,  
        cpQueued,   
        cpPresent,  
    };

    cChunk(
        int a_ChunkX, int a_ChunkZ,   // Chunk coords
        cChunkMap * a_ChunkMap, cWorld * a_World,   // Parent objects
        cChunk * a_NeighborXM, cChunk * a_NeighborXP, cChunk * a_NeighborZM, cChunk * a_NeighborZP,  // Neighbor chunks
        cAllocationPool<cChunkData::sChunkSection> & a_Pool
    );
    cChunk(cChunk & other) = delete;
    ~cChunk();

    bool IsValid(void) const {return (m_Presence == cpPresent); }

    bool IsQueued(void) const {return (m_Presence == cpQueued); }

    void SetPresence(ePresence a_Presence);

    void SetShouldGenerateIfLoadFailed(bool a_ShouldGenerateIfLoadFailed);

    void MarkRegenerating(void);

    bool IsDirty(void) const {return m_IsDirty; }

    bool CanUnload(void);

    bool CanUnloadAfterSaving(void);

    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);

    void SetAllData(cSetChunkData & a_SetChunkData);

    void SetLight(
        const cChunkDef::BlockNibbles & a_BlockLight,
        const cChunkDef::BlockNibbles & a_SkyLight
    );

    void GetBlockTypes(BLOCKTYPE  * a_BlockTypes);

    void WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes);

    bool HasBlockEntityAt(Vector3i a_BlockPos);

    void Stay(bool a_Stay = true);

    void CollectMobCensus(cMobCensus & toFill);

    void SpawnMobs(cMobSpawner & a_MobSpawner);

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

    void TickBlock(int a_RelX, int a_RelY, int a_RelZ);

    int GetPosX(void) const { return m_PosX; }
    int GetPosZ(void) const { return 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 QueueTickBlock(Vector3i a_RelPos);

    void QueueTickBlock(int a_RelX, int a_RelY, int a_RelZ)
    {
        return QueueTickBlock({a_RelX, a_RelY, a_RelZ});
    }

    void QueueTickBlockNeighbors(Vector3i a_RelPos);

    void FastSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, BLOCKTYPE a_BlockMeta, bool a_SendToClients = true);  // 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, bool a_SendToClients = true)
    {
        FastSetBlock(a_RelPos.x, a_RelPos.y, a_RelPos.z, a_BlockType, a_BlockMeta, a_SendToClients);
    }

    BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const { return m_ChunkData.GetBlock({ a_RelX, a_RelY, a_RelZ }); }
    BLOCKTYPE GetBlock(Vector3i a_RelCoords) const { return m_ChunkData.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);
    void GetBlockInfo(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight)
    {
        GetBlockInfo({ a_RelX, a_RelY, a_RelZ }, a_BlockType, a_Meta, a_SkyLight, a_BlockLight);
    }

    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);

    void CollectPickupsByPlayer(cPlayer & a_Player);

    bool SetSignLines(int a_RelX, int a_RelY, int a_RelZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);

    int  GetHeight( int a_X, int a_Z);

    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);

    bool ForEachEntity(cEntityCallback a_Callback);  // Lua-accessible

    bool ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback a_Callback);  // Lua-accessible

    bool DoWithEntityByID(UInt32 a_EntityID, cEntityCallback a_Callback, bool & a_CallbackResult);  // Lua-accessible

    template <class tyEntity, BLOCKTYPE... tBlocktype>
    bool GenericForEachBlockEntity(cFunctionRef<bool(tyEntity &)> a_Callback);

    bool ForEachBlockEntity(cBlockEntityCallback a_Callback);  // Lua-accessible

    bool ForEachBrewingstand(cBrewingstandCallback a_Callback);  // Lua-accessible

    bool ForEachChest(cChestCallback a_Callback);  // Lua-accessible

    bool ForEachDispenser(cDispenserCallback a_Callback);

    bool ForEachDropper(cDropperCallback a_Callback);

    bool ForEachDropSpenser(cDropSpenserCallback a_Callback);

    bool ForEachFurnace(cFurnaceCallback a_Callback);  // Lua-accessible

    template <class tyEntity, BLOCKTYPE... tBlocktype>
    bool GenericDoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFunctionRef<bool(tyEntity &)> a_Callback);

    bool DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback);  // Lua-acessible

    bool DoWithBeaconAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconCallback a_Callback);  // Lua-acessible

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

    bool DoWithBedAt(int a_BlockX, int a_BlockY, int a_BlockZ, cBedCallback a_Callback);  // Lua-acessible

    bool DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, cChestCallback a_Callback);  // Lua-acessible

    bool DoWithDispenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDispenserCallback a_Callback);

    bool DoWithDropperAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropperCallback a_Callback);

    bool DoWithDropSpenserAt(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserCallback a_Callback);

    bool DoWithFurnaceAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceCallback a_Callback);  // Lua-accessible

    bool DoWithNoteBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cNoteBlockCallback a_Callback);

    bool DoWithCommandBlockAt(int a_BlockX, int a_BlockY, int a_BlockZ, cCommandBlockCallback a_Callback);

    bool DoWithMobHeadAt(int a_BlockX, int a_BlockY, int a_BlockZ, cMobHeadCallback a_Callback);

    bool DoWithFlowerPotAt(int a_BlockX, int a_BlockY, int a_BlockZ, cFlowerPotCallback a_Callback);

    bool GetSignLines (int a_BlockX, int a_BlockY, int a_BlockZ, AString & a_Line1, AString & a_Line2, AString & a_Line3, AString & a_Line4);  // Lua-accessible

    bool UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z);  // [x, y, z] in world block coords

    void CalculateHeightmap(const BLOCKTYPE * a_BlockTypes);

    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 SetNextBlockTick(int a_RelX, int a_RelY, int a_RelZ)
    {
        m_BlockTickX = a_RelX;
        m_BlockTickY = a_RelY;
        m_BlockTickZ = a_RelZ;
    }

    inline NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const
    {
        return m_ChunkData.GetMeta({ a_RelX, a_RelY, a_RelZ });
    }

    NIBBLETYPE GetMeta(Vector3i a_RelPos) const { return m_ChunkData.GetMeta(a_RelPos); }

    void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Meta, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true)
    {
        SetMeta({ a_RelX, a_RelY, a_RelZ }, a_Meta, a_ShouldMarkDirty, a_ShouldInformClients);
    }

    inline void SetMeta(Vector3i a_RelPos, NIBBLETYPE a_Meta, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true)
    {
        bool hasChanged = m_ChunkData.SetMeta(a_RelPos, a_Meta);
        if (hasChanged)
        {
            if (a_ShouldMarkDirty)
            {
                MarkDirty();
            }
            if (a_ShouldInformClients)
            {
                m_PendingSendBlocks.push_back(sSetBlock(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_ChunkData.GetBlockLight(a_RelPos); }
    inline NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const { return m_ChunkData.GetBlockLight({ a_RelX, a_RelY, a_RelZ }); }

    inline NIBBLETYPE GetSkyLight(Vector3i a_RelPos) const { return m_ChunkData.GetSkyLight(a_RelPos); }
    inline NIBBLETYPE GetSkyLight(int a_RelX, int a_RelY, int a_RelZ) const { return m_ChunkData.GetSkyLight({ a_RelX, a_RelY, a_RelZ }); }

    inline NIBBLETYPE GetSkyLightAltered(Vector3i a_RelPos) const { return GetTimeAlteredLight(m_ChunkData.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);
    }

    void UnboundedQueueTickBlock(Vector3i a_RelPos);



    // Per-chunk simulator data:
    cFireSimulatorChunkData & GetFireSimulatorData (void) { return m_FireSimulatorData; }
    cFluidSimulatorData *     GetWaterSimulatorData(void) { return m_WaterSimulatorData; }
    cFluidSimulatorData *     GetLavaSimulatorData (void) { return m_LavaSimulatorData; }
    cSandSimulatorChunkData & GetSandSimulatorData (void) { return m_SandSimulatorData; }

    cRedstoneSimulatorChunkData * GetRedstoneSimulatorData(void) { return m_RedstoneSimulatorData; }
    void SetRedstoneSimulatorData(cRedstoneSimulatorChunkData * a_Data) { m_RedstoneSimulatorData = a_Data; }

    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);

    cChunkClientHandles GetAllClients(void) const
    {
        return cChunkClientHandles(m_LoadedByClient);
    }

    Vector3i RelativeToAbsolute(Vector3i a_RelBlockPosition)
    {
        return cChunkDef::RelativeToAbsolute(a_RelBlockPosition, {m_PosX, m_PosZ});
    }


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_ShouldGenerateIfLoadFailed;
    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
    bool m_HasLoadFailed;  // True if chunk failed to load and hasn't been generated yet since then

    std::vector<Vector3i> m_ToTickBlocks;
    sSetBlockVector       m_PendingSendBlocks;  

    // 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;

    int m_StayCount;

    int m_PosX, m_PosZ;
    cWorld *    m_World;
    cChunkMap * m_ChunkMap;

    cChunkData m_ChunkData;

    cChunkDef::HeightMap m_HeightMap;
    cChunkDef::BiomeMap  m_BiomeMap;

    int m_BlockTickX, m_BlockTickY, m_BlockTickZ;

    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;

    int 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 RemoveBlockEntity(cBlockEntity * a_BlockEntity);
    void AddBlockEntity   (cBlockEntity * a_BlockEntity);

    void AddBlockEntityClean(cBlockEntity * a_BlockEntity);

    void CreateBlockEntities(void);

    void WakeUpSimulators(void);

    void BroadcastPendingBlockChanges(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);
};

typedef cChunk * cChunkPtr;

typedef std::list<cChunkPtr> cChunkPtrList;