ChunkDef.h

Go to the documentation of this file.

 
// ChunkDef.h
 
// Interfaces to helper types for chunk definitions. Most modules want to include this instead of cChunk.h
 
 
 
 
 
#pragma once
 
#include "BiomeDef.h"
 
 
 
// Used to smoothly convert to new axis ordering. One will be removed when deemed stable.
#define AXIS_ORDER_YZX 1  // Original (1.1-)
#define AXIS_ORDER_XZY 2  // New (1.2+)
#define AXIS_ORDER AXIS_ORDER_XZY
 
 
 
 
 
// fwd
class cBlockEntity;
class cEntity;
class cClientHandle;
class cBlockEntity;
class cChunkCoords;
 
using OwnedEntity = std::unique_ptr<cEntity>;
using cEntityList = std::vector<OwnedEntity>;
 
 
 
 
// tolua_begin
 
typedef unsigned char BLOCKTYPE;
 
typedef unsigned char NIBBLETYPE;
 
typedef unsigned char HEIGHTTYPE;
 
// tolua_end
 
 
 
 
 
class cChunkCoords
{
public:
    int m_ChunkX;
    int m_ChunkZ;
 
    cChunkCoords(int a_ChunkX, int a_ChunkZ) : m_ChunkX(a_ChunkX), m_ChunkZ(a_ChunkZ) {}
 
 
    bool operator == (const cChunkCoords & a_Other) const
    {
        return ((m_ChunkX == a_Other.m_ChunkX) && (m_ChunkZ == a_Other.m_ChunkZ));
    }
 
 
    bool operator != (const cChunkCoords & a_Other) const
    {
        return !(operator == (a_Other));
    }
 
 
    bool operator < (const cChunkCoords & a_Other) const
    {
        if (a_Other.m_ChunkX == m_ChunkX)
        {
            return (m_ChunkZ < a_Other.m_ChunkZ);
        }
        else
        {
            return (m_ChunkX < a_Other.m_ChunkX);
        }
    }
 
 
    AString ToString() const
    {
        return fmt::format(FMT_STRING("[{}, {}]"), m_ChunkX, m_ChunkZ);
    }
} ;
 
 
 
 
 
namespace fmt
{
    template <> struct formatter<cChunkCoords>: formatter<int>
    {
        auto format(cChunkCoords a_Coords, format_context & a_Ctx)
        {
            return format_to(a_Ctx.out(), "[{}, {}]", a_Coords.m_ChunkX, a_Coords.m_ChunkZ);
        }
    };
}
 
 
 
 
 
class cChunkDef
{
public:
 
    // Chunk dimensions:
    static const int Width = 16;
    static const int Height = 256;
    static const int NumBlocks = Width * Height * Width;
 
    static const int SectionHeight = 16;
    static const size_t NumSections = (cChunkDef::Height / SectionHeight);
 
    typedef HEIGHTTYPE HeightMap[Width * Width];
 
    typedef EMCSBiome BiomeMap[Width * Width];
 
    typedef BLOCKTYPE BlockTypes[NumBlocks];
 
    typedef NIBBLETYPE BlockNibbles[NumBlocks / 2];
 
 
    inline static void AbsoluteToRelative(/* in-out */ int & a_X, int & a_Y, int & a_Z, /* out */ int & a_ChunkX, int & a_ChunkZ)
    {
        UNUSED(a_Y);
        BlockToChunk(a_X, a_Z, a_ChunkX, a_ChunkZ);
 
        a_X = a_X - a_ChunkX * Width;
        a_Z = a_Z - a_ChunkZ * Width;
    }
 
 
    inline static Vector3i AbsoluteToRelative(Vector3i a_BlockPosition)
    {
        cChunkCoords chunkPos = BlockToChunk(a_BlockPosition);
        return AbsoluteToRelative(a_BlockPosition, chunkPos);
    }
 
 
    inline static Vector3i AbsoluteToRelative(Vector3i a_BlockPosition, cChunkCoords a_ChunkPos)
    {
        return { a_BlockPosition.x - a_ChunkPos.m_ChunkX * Width, a_BlockPosition.y, a_BlockPosition.z - a_ChunkPos.m_ChunkZ * Width };
    }
 
 
    inline static Vector3i RelativeToAbsolute(Vector3i a_RelBlockPosition, cChunkCoords a_ChunkCoords)
    {
        return Vector3i(
            a_RelBlockPosition.x + a_ChunkCoords.m_ChunkX * Width,
            a_RelBlockPosition.y,
            a_RelBlockPosition.z + a_ChunkCoords.m_ChunkZ * Width
        );
    }
 
 
    inline static bool IsValidHeight(Vector3i a_BlockPosition)
    {
        return ((a_BlockPosition.y >= 0) && (a_BlockPosition.y < Height));
    }
 
 
    inline static bool IsValidWidth(int a_Width)
    {
        return ((a_Width >= 0) && (a_Width < Width));
    }
 
 
    inline static bool IsValidRelPos(Vector3i a_RelPos)
    {
        return (
            IsValidWidth(a_RelPos.x) &&
            IsValidHeight(a_RelPos) &&
            IsValidWidth(a_RelPos.z)
        );
    }
 
 
    inline static void BlockToChunk(int a_X, int a_Z, int & a_ChunkX, int & a_ChunkZ)
    {
        // This version is deprecated in favor of the vector version
        // If you're developing new code, use the other version.
        const auto ChunkCoords = BlockToChunk({ a_X, 0, a_Z });
        a_ChunkX = ChunkCoords.m_ChunkX;
        a_ChunkZ = ChunkCoords.m_ChunkZ;
    }
 
 
    inline static cChunkCoords BlockToChunk(const Vector3i a_Position)
    {
        return { FAST_FLOOR_DIV(a_Position.x, Width), FAST_FLOOR_DIV(a_Position.z, Width) };
    }
 
 
    inline static size_t MakeIndex(int x, int y, int z)
    {
        ASSERT(IsValidRelPos({ x, y, z }));
 
        #if AXIS_ORDER == AXIS_ORDER_XZY
            // For some reason, NOT using the Horner schema is faster. Weird.
            return static_cast<size_t>(x + (z * Width) + (y * Width * Width));   // 1.2 uses XZY
        #elif AXIS_ORDER == AXIS_ORDER_YZX
            return static_cast<size_t>(y + (z * Width) + (x * Height * Width));  // 1.1 uses YZX
        #endif
    }
 
 
    inline static size_t MakeIndex(Vector3i a_RelPos)
    {
        return MakeIndex(a_RelPos.x, a_RelPos.y, a_RelPos.z);
    }
 
 
    inline static Vector3i IndexToCoordinate(size_t index)
    {
        #if AXIS_ORDER == AXIS_ORDER_XZY
            return Vector3i(  // 1.2
                static_cast<int>(index % cChunkDef::Width),                       // X
                static_cast<int>(index / (cChunkDef::Width * cChunkDef::Width)),  // Y
                static_cast<int>((index / cChunkDef::Width) % cChunkDef::Width)   // Z
            );
        #elif AXIS_ORDER == AXIS_ORDER_YZX
            return Vector3i(  // 1.1
                static_cast<int>(index / (cChunkDef::Height * cChunkDef::Width)),  // X
                static_cast<int>(index % cChunkDef::Height),                       // Y
                static_cast<int>((index / cChunkDef::Height) % cChunkDef::Width)   // Z
            );
        #endif
    }
 
 
    inline static void SetBlock(BLOCKTYPE * a_BlockTypes, int a_X, int a_Y, int a_Z, BLOCKTYPE a_Type)
    {
        ASSERT((a_X >= 0) && (a_X < Width));
        ASSERT((a_Y >= 0) && (a_Y < Height));
        ASSERT((a_Z >= 0) && (a_Z < Width));
        a_BlockTypes[MakeIndex(a_X, a_Y, a_Z)] = a_Type;
    }
 
 
    inline static void SetBlock(BLOCKTYPE * a_BlockTypes, int a_Index, BLOCKTYPE a_Type)
    {
        ASSERT((a_Index >= 0) && (a_Index <= NumBlocks));
        a_BlockTypes[a_Index] = a_Type;
    }
 
 
    inline static BLOCKTYPE GetBlock(const BLOCKTYPE * a_BlockTypes, Vector3i a_RelPos)
    {
        ASSERT(IsValidRelPos(a_RelPos));
        return a_BlockTypes[MakeIndex(a_RelPos)];
    }
 
 
    inline static BLOCKTYPE GetBlock(const BLOCKTYPE * a_BlockTypes, int a_X, int a_Y, int a_Z)
    {
        ASSERT((a_X >= 0) && (a_X < Width));
        ASSERT((a_Y >= 0) && (a_Y < Height));
        ASSERT((a_Z >= 0) && (a_Z < Width));
        return a_BlockTypes[MakeIndex(a_X, a_Y, a_Z)];
    }
 
 
    inline static BLOCKTYPE GetBlock(const BLOCKTYPE * a_BlockTypes, int a_Idx)
    {
        ASSERT((a_Idx >= 0) && (a_Idx < NumBlocks));
        return a_BlockTypes[a_Idx];
    }
 
 
    inline static HEIGHTTYPE GetHeight(const HeightMap & a_HeightMap, int a_X, int a_Z)
    {
        ASSERT((a_X >= 0) && (a_X < Width));
        ASSERT((a_Z >= 0) && (a_Z < Width));
        return a_HeightMap[a_X + Width * a_Z];
    }
 
 
    inline static void SetHeight(HeightMap & a_HeightMap, int a_X, int a_Z, HEIGHTTYPE a_Height)
    {
        ASSERT((a_X >= 0) && (a_X < Width));
        ASSERT((a_Z >= 0) && (a_Z < Width));
        a_HeightMap[a_X + Width * a_Z] = a_Height;
    }
 
 
    inline static EMCSBiome GetBiome(const BiomeMap & a_BiomeMap, int a_X, int a_Z)
    {
        ASSERT((a_X >= 0) && (a_X < Width));
        ASSERT((a_Z >= 0) && (a_Z < Width));
        return a_BiomeMap[a_X + Width * a_Z];
    }
 
 
    inline static void SetBiome(BiomeMap & a_BiomeMap, int a_X, int a_Z, EMCSBiome a_Biome)
    {
        ASSERT((a_X >= 0) && (a_X < Width));
        ASSERT((a_Z >= 0) && (a_Z < Width));
        a_BiomeMap[a_X + Width * a_Z] = a_Biome;
    }
 
 
    static NIBBLETYPE GetNibble(const NIBBLETYPE * a_Buffer, int x, int y, int z)
    {
        if ((x < Width) && (x > -1) && (y < Height) && (y > -1) && (z < Width) && (z > -1))
        {
            return ExpandNibble(a_Buffer, MakeIndex(x, y, z));
        }
        ASSERT(!"cChunkDef::GetNibble(): coords out of chunk range!");
        return 0;
    }
 
 
    inline static void PackNibble(NIBBLETYPE * const a_Buffer, const size_t a_Index, const NIBBLETYPE a_Nibble)
    {
        ASSERT((a_Nibble & 0xF) == a_Nibble);  // Only the lower bits should be set
 
        a_Buffer[a_Index / 2] = static_cast<NIBBLETYPE>(
            (a_Buffer[a_Index / 2] & (0xf0 >> ((a_Index & 1) * 4))) |  // The untouched nibble
            ((a_Nibble & 0x0f) << ((a_Index & 1) * 4))  // The nibble being set
        );
    }
 
 
    inline static NIBBLETYPE ExpandNibble(const NIBBLETYPE * const a_Buffer, const size_t a_Index)
    {
        return (a_Buffer[a_Index / 2] >> ((a_Index & 1) * 4)) & 0x0f;
    }
} ;
 
 
 
 
 
class cClientDiffCallback
{
public:
 
    virtual ~cClientDiffCallback() {}
 
    virtual void Removed(cClientHandle * a_Client) = 0;
 
    virtual void Added(cClientHandle * a_Client) = 0;
} ;
 
 
 
 
 
struct sSetBlock
{
    int m_RelX, m_RelY, m_RelZ;
    int m_ChunkX, m_ChunkZ;
    BLOCKTYPE m_BlockType;
    NIBBLETYPE m_BlockMeta;
 
    sSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta):
        m_RelX(a_BlockX),
        m_RelY(a_BlockY),
        m_RelZ(a_BlockZ),
        m_BlockType(a_BlockType),
        m_BlockMeta(a_BlockMeta)
    {
        cChunkDef::AbsoluteToRelative(m_RelX, m_RelY, m_RelZ, m_ChunkX, m_ChunkZ);
    }
 
    sSetBlock(Vector3i a_BlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) :
        sSetBlock(a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, a_BlockType, a_BlockMeta)
    {
    }
 
    sSetBlock(int a_ChunkX, int a_ChunkZ, int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) :
        m_RelX(a_RelX), m_RelY(a_RelY), m_RelZ(a_RelZ),
        m_ChunkX(a_ChunkX), m_ChunkZ(a_ChunkZ),
        m_BlockType(a_BlockType),
        m_BlockMeta(a_BlockMeta)
    {
        ASSERT((a_RelX >= 0) && (a_RelX < cChunkDef::Width));
        ASSERT((a_RelZ >= 0) && (a_RelZ < cChunkDef::Width));
    }
 
    int GetX(void) const { return m_RelX + cChunkDef::Width * m_ChunkX; }
 
    int GetY(void) const { return m_RelY; }
 
    int GetZ(void) const { return m_RelZ + cChunkDef::Width * m_ChunkZ; }
 
    Vector3i GetAbsolutePos() const
    {
        return Vector3i(GetX(), GetY(), GetZ());
    }
 
    Vector3i GetRelativePos() const
    {
        return Vector3i(m_RelX, m_RelY, m_RelZ);
    }
};
 
typedef std::vector<sSetBlock> sSetBlockVector;
 
typedef std::list<cChunkCoords> cChunkCoordsList;
typedef std::vector<cChunkCoords> cChunkCoordsVector;
 
 
 
 
 
class cChunkCoordsHash
{
public:
    size_t operator () (const cChunkCoords & a_Coords) const
    {
        return (static_cast<size_t>(a_Coords.m_ChunkX) << 16) ^ static_cast<size_t>(a_Coords.m_ChunkZ);
    }
};
 
 
 
 
 
class cChunkCoordCallback
{
public:
 
    virtual ~cChunkCoordCallback() {}
 
    virtual void Call(cChunkCoords a_Coords, bool a_IsSuccess) = 0;
} ;
 
 
 
 
 
template <typename X> class cCoordWithData
{
public:
    int x;
    int y;
    int z;
    X   Data;
 
    cCoordWithData(int a_X, int a_Y, int a_Z) :
        x(a_X), y(a_Y), z(a_Z), Data()
    {
    }
 
    cCoordWithData(int a_X, int a_Y, int a_Z, const X & a_Data) :
        x(a_X), y(a_Y), z(a_Z), Data(a_Data)
    {
    }
} ;
 
typedef cCoordWithData<int>        cCoordWithInt;
 
typedef std::list<cCoordWithInt>   cCoordWithIntList;
typedef std::vector<cCoordWithInt> cCoordWithIntVector;