BlockArea.h

Go to the documentation of this file.

 
// BlockArea.h
 
// Interfaces to the cBlockArea object representing an area of block data that can be queried from cWorld and then accessed again without further queries
// The object also supports writing the blockdata back into cWorld, even into other coords
 
// NOTE: All Nibble values (meta, blocklight, skylight) are stored one-nibble-per-byte for faster access / editting!
// NOTE: Lua bindings for this object explicitly check parameter values. C++ code is expected to pass in valid params, so the functions ASSERT on invalid params.
//    This includes the datatypes (must be present / valid combination), coords and sizes.
 
 
 
 
 
#pragma once
 
#include "BlockType.h"
#include "ForEachChunkProvider.h"
#include "ChunkDataCallback.h"
#include "Cuboid.h"
#include "FunctionRef.h"
#include "BlockEntities/BlockEntity.h"
 
 
 
 
// fwd:
class cCuboid;
class cItem;
class cItems;
using cBlockEntityCallback = cFunctionRef<bool(cBlockEntity &)>;
 
 
 
 
// tolua_begin
class cBlockArea
{
    // tolua_end
    DISALLOW_COPY_AND_ASSIGN(cBlockArea);
    // tolua_begin
 
public:
 
    enum
    {
        baTypes         =  1,
        baMetas         =  2,
        baLight         =  4,
        baSkyLight      =  8,
        // baEntities   = 16,  // Not supported yet
        baBlockEntities = 32,
    } ;
 
    enum eMergeStrategy
    {
        msOverwrite,
        msFillAir,
        msImprint,
        msLake,
        msSpongePrint,
        msDifference,
        msSimpleCompare,
        msMask,
    } ;
 
    cBlockArea(void);
 
    static bool IsValidDataTypeCombination(int a_DataTypes);
 
    void Clear(void);
 
    // tolua_end
 
    void Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
    void Create(const Vector3i & a_Size, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
    // tolua_begin
 
    void SetOrigin(int a_OriginX, int a_OriginY, int a_OriginZ);
 
    void SetOrigin(const Vector3i & a_Origin);
 
    bool IsValidRelCoords(int a_RelX, int a_RelY, int a_RelZ) const;
 
    bool IsValidRelCoords(const Vector3i & a_RelCoords) const;
 
    bool IsValidCoords(int a_BlockX, int a_BlockY, int a_BlockZ) const;
 
    bool IsValidCoords(const Vector3i & a_Coords) const;
 
    // tolua_end
 
    bool Read(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
    bool Read(cForEachChunkProvider & a_ForEachChunkProvider, const cCuboid & a_Bounds, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
    bool Read(cForEachChunkProvider & a_ForEachChunkProvider, const Vector3i & a_Point1, const Vector3i & a_Point2, int a_DataTypes = baTypes | baMetas | baBlockEntities);
 
    // TODO: Write() is not too good an interface: if it fails, there's no way to repeat only for the parts that didn't write
    // A better way may be to return a list of cBlockAreas for each part that didn't succeed writing, so that the caller may try again
 
    bool Write(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes);
 
    bool Write(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ)
    {
        // Write all available data
        return Write(a_ForEachChunkProvider, a_MinBlockX, a_MinBlockY, a_MinBlockZ, GetDataTypes());
    }
 
    bool Write(cForEachChunkProvider & a_ForEachChunkProvider, const Vector3i & a_MinCoords, int a_DataTypes);
 
    bool Write(cForEachChunkProvider & a_ForEachChunkProvider, const Vector3i & a_MinCoords)
    {
        // Write all available data
        return Write(a_ForEachChunkProvider, a_MinCoords.x, a_MinCoords.y, a_MinCoords.z, GetDataTypes());
    }
 
    // tolua_begin
 
    void CopyTo(cBlockArea & a_Into) const;
 
    void CopyFrom(const cBlockArea & a_From);
 
    void DumpToRawFile(const AString & a_FileName);
 
    void Crop(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ);
 
    void Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
 
    void Merge(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_RelZ, eMergeStrategy a_Strategy);
 
    void Merge(const cBlockArea & a_Src, const Vector3i & a_RelMinCoords, eMergeStrategy a_Strategy);
 
    void Fill(int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0, NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f);
 
    // tolua_end
 
    void FillRelCuboid(int a_MinRelX, int a_MaxRelX, int a_MinRelY, int a_MaxRelY, int a_MinRelZ, int a_MaxRelZ,
        int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
        NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
    );
 
    void FillRelCuboid(const cCuboid & a_RelCuboid,
        int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
        NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
    );
 
    void RelLine(int a_RelX1, int a_RelY1, int a_RelZ1, int a_RelX2, int a_RelY2, int a_RelZ2,
        int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
        NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
    );
 
    void RelLine(const Vector3i & a_Point1, const Vector3i & a_Point2,
        int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta = 0,
        NIBBLETYPE a_BlockLight = 0, NIBBLETYPE a_BlockSkyLight = 0x0f
    );
 
    // tolua_begin
 
    void RotateCCW(void);
 
    void RotateCW(void);
 
    void MirrorXY(void);
 
    void MirrorXZ(void);
 
    void MirrorYZ(void);
 
    void RotateCCWNoMeta(void);
 
    void RotateCWNoMeta(void);
 
    void MirrorXYNoMeta(void);
 
    void MirrorXZNoMeta(void);
 
    void MirrorYZNoMeta(void);
 
    // tolua_end
 
    // Setters:
    void SetRelBlockType    (int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE  a_BlockType);
    void SetBlockType       (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE  a_BlockType);
    void SetRelBlockMeta    (int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockMeta);
    void SetBlockMeta       (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockMeta);
    void SetRelBlockLight   (int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockLight);
    void SetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockLight);
    void SetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_BlockSkyLight);
    void SetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockSkyLight);
 
    // tolua_begin
 
    void SetWEOffset (int a_OffsetX, int a_OffsetY, int a_OffsetZ);
    void SetWEOffset (const Vector3i & a_Offset);
    const Vector3i & GetWEOffset  (void) const {return m_WEOffset;}
 
    // tolua_end
 
    // Getters:
    BLOCKTYPE  GetRelBlockType    (int a_RelX,   int a_RelY,   int a_RelZ)   const;
    BLOCKTYPE  GetBlockType       (int a_BlockX, int a_BlockY, int a_BlockZ) const;
    NIBBLETYPE GetRelBlockMeta    (int a_RelX,   int a_RelY,   int a_RelZ)   const;
    NIBBLETYPE GetBlockMeta       (int a_BlockX, int a_BlockY, int a_BlockZ) const;
    NIBBLETYPE GetRelBlockLight   (int a_RelX,   int a_RelY,   int a_RelZ)   const;
    NIBBLETYPE GetBlockLight      (int a_BlockX, int a_BlockY, int a_BlockZ) const;
    NIBBLETYPE GetRelBlockSkyLight(int a_RelX,   int a_RelY,   int a_RelZ)   const;
    NIBBLETYPE GetBlockSkyLight   (int a_BlockX, int a_BlockY, int a_BlockZ) const;
 
    void SetBlockTypeMeta   (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
    void SetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE a_BlockType,   NIBBLETYPE a_BlockMeta);
 
    void GetBlockTypeMeta   (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
    void GetRelBlockTypeMeta(int a_RelX,   int a_RelY,   int a_RelZ,   BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
 
    const Vector3i & GetSize(void) const { return m_Size; }
    const Vector3i & GetOrigin(void) const { return m_Origin; }
 
    // tolua_begin
 
    cCuboid GetBounds(void) const;
 
    int GetSizeX(void) const { return m_Size.x; }
    int GetSizeY(void) const { return m_Size.y; }
    int GetSizeZ(void) const { return m_Size.z; }
 
    int GetVolume(void) const { return m_Size.x * m_Size.y * m_Size.z; }
 
    int GetOriginX(void) const { return m_Origin.x; }
    int GetOriginY(void) const { return m_Origin.y; }
    int GetOriginZ(void) const { return m_Origin.z; }
 
    int GetDataTypes(void) const;
 
    bool HasBlockTypes    (void) const { return (m_BlockTypes    != nullptr); }
    bool HasBlockMetas    (void) const { return (m_BlockMetas    != nullptr); }
    bool HasBlockLights   (void) const { return (m_BlockLight    != nullptr); }
    bool HasBlockSkyLights(void) const { return (m_BlockSkyLight != nullptr); }
    bool HasBlockEntities (void) const { return (m_BlockEntities != nullptr); }
 
    size_t CountNonAirBlocks(void) const;
 
    size_t CountSpecificBlocks(BLOCKTYPE a_BlockType) const;
 
    size_t CountSpecificBlocks(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) const;
 
    // tolua_end
 
    void GetNonAirCropRelCoords(int & a_MinRelX, int & a_MinRelY, int & a_MinRelZ, int & a_MaxRelX, int & a_MaxRelY, int & a_MaxRelZ, BLOCKTYPE a_IgnoreBlockType = E_BLOCK_AIR);
 
    // Clients can use these for faster access to all blocktypes. Be careful though!
    BLOCKTYPE *  GetBlockTypes   (void) const { return m_BlockTypes.get();    }
    NIBBLETYPE * GetBlockMetas   (void) const { return m_BlockMetas.get();    }  // NOTE: one byte per block!
    NIBBLETYPE * GetBlockLight   (void) const { return m_BlockLight.get();    }  // NOTE: one byte per block!
    NIBBLETYPE * GetBlockSkyLight(void) const { return m_BlockSkyLight.get(); }  // NOTE: one byte per block!
    size_t       GetBlockCount(void) const { return static_cast<size_t>(m_Size.x * m_Size.y * m_Size.z); }
    static size_t MakeIndexForSize(Vector3i a_RelPos, Vector3i a_Size);
 
    size_t MakeIndex(Vector3i a_RelPos) const
    {
        return MakeIndexForSize(a_RelPos, m_Size);
    }
 
    size_t MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const
    {
        return MakeIndexForSize({ a_RelX, a_RelY, a_RelZ }, m_Size);
    }
 
    bool DoWithBlockEntityRelAt(int a_RelX, int a_RelY, int a_RelZ, cBlockEntityCallback a_Callback);
 
    bool DoWithBlockEntityAt   (int a_BlockX, int a_BlockY, int a_BlockZ, cBlockEntityCallback a_Callback);
 
    bool ForEachBlockEntity(cBlockEntityCallback a_Callback);
 
    const cBlockEntities & GetBlockEntities(void) const { ASSERT(HasBlockEntities()); return *m_BlockEntities; }
 
 
 
protected:
 
    friend class cChunkDesc;
    friend class cSchematicFileSerializer;
 
    class cChunkReader:
        public cChunkDataCallback
    {
    public:
        cChunkReader(cBlockArea & a_Area);
 
    protected:
        cBlockArea & m_Area;
        cCuboid m_AreaBounds;  
        Vector3i m_Origin;
        int m_CurrentChunkX;
        int m_CurrentChunkZ;
 
        void CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc);
 
        // cChunkDataCallback overrides:
        virtual bool Coords(int a_ChunkX, int a_ChunkZ) override;
        virtual void ChunkData(const ChunkBlockData & a_BlockData, const ChunkLightData & a_LightData) override;
        virtual void BlockEntity(cBlockEntity * a_BlockEntity) override;
    } ;
 
    using NIBBLEARRAY = std::unique_ptr<NIBBLETYPE[]>;
    using BLOCKARRAY = std::unique_ptr<BLOCKTYPE[]>;
    using cBlockEntitiesPtr = std::unique_ptr<cBlockEntities>;
 
    Vector3i m_Origin;
    Vector3i m_Size;
 
    Vector3i m_WEOffset;
 
    BLOCKARRAY  m_BlockTypes;
    NIBBLEARRAY m_BlockMetas;     // Each meta is stored as a separate byte for faster access
    NIBBLEARRAY m_BlockLight;     // Each light value is stored as a separate byte for faster access
    NIBBLEARRAY m_BlockSkyLight;  // Each light value is stored as a separate byte for faster access
 
    cBlockEntitiesPtr m_BlockEntities;
 
    bool SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes);
 
    // Basic Setters:
    void SetRelNibble(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE a_Value, NIBBLETYPE * a_Array);
    void SetNibble   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array);
 
    // Basic Getters:
    NIBBLETYPE GetRelNibble(int a_RelX,   int a_RelY,   int a_RelZ,   NIBBLETYPE * a_Array) const;
    NIBBLETYPE GetNibble   (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array) const;
 
    // Crop helpers:
    void CropBlockTypes(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ);
    void CropNibbles   (NIBBLEARRAY & a_Array, int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ);
 
    // Expand helpers:
    void ExpandBlockTypes(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
    void ExpandNibbles   (NIBBLEARRAY & a_Array, int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
 
    void RelSetData(
        int a_RelX, int a_RelY, int a_RelZ,
        int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
        NIBBLETYPE a_BlockLight, NIBBLETYPE a_BlockSkyLight
    );
 
    template <bool MetasValid>
    void MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_RelY, int a_RelZ, eMergeStrategy a_Strategy, const NIBBLETYPE * SrcMetas, NIBBLETYPE * DstMetas);
 
    void MergeBlockEntities(int a_RelX, int a_RelY, int a_RelZ, const cBlockArea & a_Src);
 
    void RescanBlockEntities(void);
 
    void RemoveNonMatchingBlockEntities(void);
 
    cBlockEntity * GetBlockEntityRel(Vector3i a_RelPos);
 
    // tolua_begin
} ;
// tolua_end