class Palette
{
  struct BlockDef
  {
    std::string mBlockTypeName;  // such as "minecraft:acacia_door"
    size_t mBlockStateIndex;  // Index into global BlockStatePalette
  };
  std::map<UInt32, BlockDef> mBlockTypeMap;
};

using BlockState = map<std::string, std::string>;  // For simplicity, only consider strings as values for now

class BlockStatePalette
{
  std::map<size_t, BlockState> mBlockStateMap;
};

// global:
BlockStatePalette gBlockStatePalette;

class BlockArea
{
  UInt32 mBlocks[];  // To be replaced by smaller numbers when possible
  Palette mPalette;
  
  std::pair<const AString &, const BlockState &> block(const Vector3i & aPos)
  {
    UInt32 paletteIndex = mBlocks[...];
    const AString & blockTypeName = mPalette.mBlockTypeMap[paletteIndex].mBlockTypeName;
    const BlockState & blockState = gPalette.mBlockStateMap[mPalette.mBlockTypeMap[paletteIndex].mBlockStateIndex];
    return {blockTypeName, blockState};
  }
};

class BlockInfo
{
  AString mTypeName;
  std::map<AString, AString> mHints;
  std::function<UInt8(const AString & aTypeName, const BlockState & aBlockState)> mLightValueCallback;
  std::function<...> mXYZCallback;//  ...
}

Quote:So I guess the best structure to support all this is a free-form map of string->string for "hints" ..

(01-22-2019, 06:56 PM)NiLSPACE Wrote: I Assume the key is the name of the block, but what would be the value?

• A BlockId that is just a unique number for that block name
  
• A contiguous range of BlockStateId values on the global palette which uniquely represent block name + block state
  

• The chunk local palette only stores a single index into the global palette, not name + index as your example shows.
  
• The "meta value" is still just dumb data like BlockMeta is currently and won't require any new data structures.
  
• The "meta value" can be calculated directly from the BlockStateId
           BlockStateMeta = BlockStateId - (Lowest BlockStateId for this block type)
  So it's really just a State index that's specific to that block type.
  
• When you need to access individual values from the block state it could be handled by the respective block handler. I pass in the meta value and it returns a struct with the components or alternatively just have query functions like many block handlers have currently.
  

enum class BlockId : UInt16 {};        // The new BlockType
enum class BlockStateId : UInt32 {};   // Global Id specifies both Type & Meta 
enum class BlockStateMeta : UInt16 {}; // State index for a known block type

class BlockPalette
{
public:

    struct BlockData
    {
        BlockId m_Id;
        BlockStateMeta m_State;
    };

    BlockId GetBlockId(const AString & a_BlockName) const;
    BlockId GetBlockId(BlockStateId a_StateId) const;

    BlockData GetBlockData(BlockStateId a_StateId) const;

    BlockId RegisterBlock(const AString & a_BlockName, UInt16 a_NumStates);

private:
    std::vector<BlockStateId> m_BlockIdToStateId;
    std::vector<AString> m_BlockIdToName;
    std::unordered_map<AString, BlockId> m_NameToBlockId;

};

BlockPalette gBlockStatePalette;

using ChunkPalette = std::map<UInt32, BlockStateId> mBlockStateMap;

class BlockArea
{
    UInt32 mBlocks[];  // To be replaced by smaller numbers when possible
    ChunkPalette mPalette;

    BlockData block(const Vector3i & aPos)
    {
        const UInt32 paletteIndex = mBlocks[...];
        const BlockStateId StateId = mPalette.mBlockStateMap[paletteIndex];
        return gPalette.GetBlockData(StateId);
    }
};

(01-23-2019, 09:49 AM)peterbell10 Wrote: [...] you also specify how many unique block states are required [...]