ChunkMap.h

Go to the documentation of this file.

 
// cChunkMap.h
 
// Interfaces to the cChunkMap class representing the chunk storage for a single world
 
#pragma once
 
#include "ChunkDataCallback.h"
#include "EffectID.h"
#include "FunctionRef.h"
 
 
 
 
class cWorld;
class cItem;
class cItems;
class cChunkStay;
class cChunk;
class cPlayer;
class cBlockArea;
class cMobCensus;
class cMobSpawner;
class cBoundingBox;
class cDeadlockDetect;
 
struct SetChunkData;
 
using cChunkCallback        = cFunctionRef<bool(cChunk       &)>;
using cEntityCallback       = cFunctionRef<bool(cEntity      &)>;
using cBlockEntityCallback  = cFunctionRef<bool(cBlockEntity &)>;
 
 
 
 
 
class cChunkMap
{
public:
 
    cChunkMap(cWorld * a_World);
 
    void SendBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cClientHandle & a_Client);
 
    bool UseBlockEntity(cPlayer * a_Player, int a_X, int a_Y, int a_Z);
 
    bool DoWithChunk(int a_ChunkX, int a_ChunkZ, cChunkCallback a_Callback);
 
    bool DoWithChunkAt(Vector3i a_BlockPos, cChunkCallback a_Callback);
 
    void WakeUpSimulators(Vector3i a_Block);
 
    // DEPRECATED, use the vector-parametered version instead.
    void WakeUpSimulators(int a_BlockX, int a_BlockY, int a_BlockZ)
    {
        LOGWARNING("cChunkMap::WakeUpSimulators(int, int, int) is deprecated, use cChunkMap::WakeUpSimulators(Vector3i) instead.");
        WakeUpSimulators(Vector3i(a_BlockX, a_BlockY, a_BlockZ));
    }
 
    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 SetChunkData(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 IsWeatherSunnyAt(int a_BlockX, int a_BlockZ) const;
    bool IsWeatherWetAt(int a_BlockX, int a_BlockZ) const;
    bool IsWeatherWetAt(Vector3i a_Position) const;
 
    bool      IsChunkValid       (int a_ChunkX, int a_ChunkZ) const;
    bool      HasChunkAnyClients (int a_ChunkX, int a_ChunkZ) const;
    int       GetHeight          (int a_BlockX, int a_BlockZ);  // Waits for the chunk to get loaded / generated
    bool      TryGetHeight       (int a_BlockX, int a_BlockZ, int & a_Height);  // Returns false if chunk not loaded / generated
 
    void FastSetBlock(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
    void CollectPickupsByEntity(cEntity & a_Entity);
 
    BLOCKTYPE  GetBlock          (Vector3i a_BlockPos) const;
    NIBBLETYPE GetBlockMeta      (Vector3i a_BlockPos) const;
    NIBBLETYPE GetBlockSkyLight  (Vector3i a_BlockPos) const;
    NIBBLETYPE GetBlockBlockLight(Vector3i a_BlockPos) const;
 
    void SetBlockMeta(Vector3i a_BlockPos, NIBBLETYPE a_BlockMeta);
 
    void SetBlock          (Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
    bool GetBlockTypeMeta  (Vector3i a_BlockPos, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
    bool GetBlockInfo      (Vector3i, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight) const;
 
    void ReplaceTreeBlocks(const sSetBlockVector & a_Blocks);
 
    EMCSBiome GetBiomeAt(int a_BlockX, int a_BlockZ) const;
 
    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 GetBlocks(sSetBlockVector & a_Blocks, bool a_ContinueOnFailure);
 
    bool DigBlock(Vector3i a_BlockPos);
 
    cItems PickupsFromBlock(Vector3i a_BlockPos, const cEntity * a_Digger, const cItem * a_Tool);
 
    void SendBlockTo(int a_BlockX, int a_BlockY, int a_BlockZ, const cPlayer & a_Player);
 
    void CompareChunkClients(int a_ChunkX1, int a_ChunkZ1, int a_ChunkX2, int a_ChunkZ2, cClientDiffCallback & a_Callback);
 
    void CompareChunkClients(cChunk * a_Chunk1, cChunk * a_Chunk2, 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 AddEntity(OwnedEntity a_Entity);
 
    void AddPlayer(std::unique_ptr<cPlayer> a_Player);
 
    bool HasEntity(UInt32 a_EntityID) const;
 
    OwnedEntity RemoveEntity(cEntity & a_Entity);
 
    bool ForEachEntity(cEntityCallback a_Callback) const;  // Lua-accessible
 
    bool ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback a_Callback);  // Lua-accessible
 
    bool ForEachEntityInBox(const cBoundingBox & a_Box, cEntityCallback a_Callback);  // Lua-accessible
 
    bool DoWithEntityByID(UInt32 a_EntityID, cEntityCallback a_Callback) const;  // Lua-accessible
 
    bool ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEntityCallback a_Callback);  // Lua-accessible
 
    bool DoWithBlockEntityAt(Vector3i a_Position, cBlockEntityCallback a_Callback);  // Lua-acessible
 
    void PrepareChunk(int a_ChunkX, int a_ChunkZ, std::unique_ptr<cChunkCoordCallback> a_CallAfter = {});  // Lua-accessible
 
    void GenerateChunk(int a_ChunkX, int a_ChunkZ);  // Lua-accessible
 
    void ChunkLoadFailed(int a_ChunkX, int a_ChunkZ);
 
    void MarkChunkRegenerating(int a_ChunkX, int a_ChunkZ);
 
    bool IsChunkLighted(int a_ChunkX, int a_ChunkZ);
 
    bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback);
 
    bool ForEachLoadedChunk(cFunctionRef<bool(int, int)> a_Callback) const;
 
    bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes);
 
    void GetChunkStats(int & a_NumChunksValid, int & a_NumChunksDirty) const;
 
    int GrowPlantAt(Vector3i a_BlockPos, int a_NumStages = 1);
 
    void SetNextBlockToTick(const Vector3i a_BlockPos);
 
    void CollectMobCensus(cMobCensus & a_ToFill);
 
    void SpawnMobs(cMobSpawner & a_MobSpawner);
 
    void Tick(std::chrono::milliseconds a_Dt);
 
    void TickBlock(const Vector3i a_BlockPos);
 
    void UnloadUnusedChunks(void);
    void SaveAllChunks(void) const;
 
    cWorld * GetWorld(void) const { return m_World; }
 
    size_t GetNumChunks(void) const;
 
    size_t GetNumUnusedDirtyChunks(void) const;
 
    void ChunkValidated(void);  // Called by chunks that have become valid
 
    cCriticalSection & GetCS(void) const { return m_CSChunks; }
 
    void SetChunkAlwaysTicked(int a_ChunkX, int a_ChunkZ, bool a_AlwaysTicked);
 
    void TrackInDeadlockDetect(cDeadlockDetect & a_DeadlockDetect, const AString & a_WorldName);
 
    void UntrackInDeadlockDetect(cDeadlockDetect & a_DeadlockDetect);
 
private:
 
    // Chunks query their neighbors using FindChunk(), while being ticked
    friend class cChunk;
 
    // The chunkstay can (de-)register itself using AddChunkStay() and DelChunkStay()
    friend class cChunkStay;
 
    typedef std::list<cChunkStay *> cChunkStays;
 
    mutable cCriticalSection m_CSChunks;
 
    std::map<cChunkCoords, cChunk> m_Chunks;
 
    cEvent m_evtChunkValid;  // Set whenever any chunk becomes valid, via ChunkValidated()
 
    cWorld * m_World;
 
    cChunkStays m_ChunkStays;
 
    cChunk & ConstructChunk(int a_ChunkX, int a_ChunkZ);
 
    cChunk & GetChunk(int a_ChunkX, int a_ChunkZ);
 
    cChunk * FindChunk(int a_ChunkX, int a_ChunkZ);
 
    const cChunk * FindChunk(int a_ChunkX, int a_ChunkZ) const;
 
    void AddChunkStay(cChunkStay & a_ChunkStay);
 
    void DelChunkStay(cChunkStay & a_ChunkStay);
 
};