3 files changed, 737 insertions, 165 deletions

diff --git a/Tools/BlockTypePaletteGenerator/Generator.lua b/Tools/BlockTypePaletteGenerator/Generator.lua
index b052ffa92..0b8dfec64 100644
--- a/Tools/BlockTypePaletteGenerator/Generator.lua
+++ b/Tools/BlockTypePaletteGenerator/Generator.lua
@@ -1,165 +1,496 @@
--- Generator.lua
-
---[[
-Crafts an intermediate block palette format to be read by Cuberite.
-It processes the blocks.json report file (https://wiki.vg/Data_Generators)
-into a file that can be loaded into a BlockTypePalette (and is to be stored
-as Server/Protocol/<version>/base.btp.txt).
-
-The output format is the regular TSV BlockTypePalette, described in the
-$/src/BlockTypePalette.h file.
---]]
-
-
-
-
--- Allow Lua to load libraries in our subfolder:
-package.path = 'lib/lunajson/src/?.lua;' .. package.path;
-
-
-
-
-
-
---- Prints usage instructions to stdout.
--- If the optional `aMessage` is passed, output is prepended by message _and_
--- redirected to stderr.
-local function usage(aMessage)
-	if aMessage then
-		io.output(io.stderr);
-		io.write(aMessage, "\n\n");
-	end
-	io.write(
-		"Usage: lua Generator.lua INPUTFILE OUTPUTFILE\n"..
-		"Converts the Minecraft blocks.json report format to the cuberite "..
-		"block type palette format.\n"..
-		"\n"..
-		"INPUTFILE and OUTPUTFILE must point to a valid path. INPUTFILE must "..
-		"be readable and OUTPUTFILE must be writable. Either can be replaced "..
-		"with `-` (dash character) to point to standard-input or -output.\n");
-	os.exit(message and 1 or 0);
-end
-
-
-
-
-
---- Parses the JSON registry into a Lua table
---[[ The returned array-table has the following format:
-{
-	{ id = 1, blockTypeName = "minecraft:stone", properties = {key = value, ...} },
-	...
-}
---]]
-local function parseRegistry(aBlockRegistryJsonStr)
-	assert(type(aBlockRegistryJsonStr) == "string")
-
-	local lj = require("lunajson")
-	local input = lj.decode(aBlockRegistryJsonStr)
-	local registry = {}
-	local idx = 1
-	for blockTypeName, blockData in pairs(input) do
-		for _, state in pairs(blockData.states) do
-			registry[idx] = {
-				id = state.id,
-				blockTypeName = blockTypeName,
-				properties = state.properties,
-			}
-			idx = idx + 1
-		end
-	end
-	return registry
-end
-
-
-
-
-
---- Serializes the properties from the JSON / array table format into a single output string
--- Concatenates all properties with \t as the delimiting character
-local function serializeProperties(aProperties)
-	local res = {}
-	local idx = 1
-	for k, v in pairs(aProperties or {}) do
-		res[idx] = k
-		res[idx + 1] = v
-		idx = idx + 2
-	end
-	return table.concat(res, "\t")
-end
-
-
-
-
-
---- Returns the prefix that is common for all block type names in the registry
--- aRegistry is the parsed registry, as returned from parseRegistry()
-local function findCommonPrefix(aRegistryTable)
-	local prefix = aRegistryTable[1].blockTypeName
-	local len = string.len(prefix)
-	local sub = string.sub
-	for _, block in ipairs(aRegistryTable) do
-		while (sub(block.blockTypeName, 1, len) ~= prefix) do
-			len = len - 1
-			if (len == 0) then
-				return ""
-			end
-			prefix = sub(prefix, 1, len)
-		end
-	end
-	return prefix
-end
-
-
-
-
-
--- Test whether the script is run in a path where it can load it's libraries
-if not(pcall(function() require("lunajson") end)) then
-	usage(
-		"Could not load required libraries, please run `Generator.lua` " ..
-		"within its directory and make sure to run `git submodule update`."
-	)
-end
-
--- Check/Prepare CLI arguments
-local inpath, outpath = ...;
-inpath = inpath or "blocks.json"
-outpath = outpath or "base.btp.txt"
-if (inpath ~= "-") then
-	local handle, err = io.open(inpath, "r")
-	io.input(handle or usage(err))
-end
-if (outpath ~= "-") then
-	local handle, err = io.open(outpath, "w")
-	io.output(handle or usage(err))
-end
-
--- Parse the registry:
-local registry = parseRegistry(io.input():read("*a"))
-local commonPrefix = findCommonPrefix(registry)
-
--- Sort the entries:
-table.sort(registry,
-	function (entry1, entry2)
-		return (entry1.id < entry2.id)
-	end
-)
-
--- Write out the output format:
-io.write("BlockTypePalette\n")
-io.write("FileVersion\t1\n")
-io.write("CommonPrefix\t", commonPrefix, "\n")
-io.write("\n")
-local prefixLen = string.len(commonPrefix) + 1
-for _, entry in ipairs(registry) do
-	local props = serializeProperties(entry.properties)
-	if (props ~= "") then
-		props = "\t" .. props
-	end
-	io.write(
-		entry.id, "\t",
-		string.sub(entry.blockTypeName, prefixLen),
-		props, "\n"
-	)
-end
+-- Generator.lua

+

+--[[

+Crafts an intermediate block palette format to be read by Cuberite.

+It processes the blocks.json report file (https://wiki.vg/Data_Generators)

+into a file that can be loaded into a BlockTypePalette (and is to be stored

+as Server/Protocol/<version>/base.btp.txt).

+

+The output format is the regular TSV BlockTypePalette, described in the

+$/src/BlockTypePalette.h file.

+--]]

+

+

+

+

+-- Allow Lua to load libraries in our subfolder:

+package.path = 'lib/lunajson/src/?.lua;' .. package.path;

+

+

+

+

+function spairs(t, order)

+    -- collect the keys

+    local keys = {}

+    for k in pairs(t) do keys[#keys+1] = k end

+

+    -- if order function given, sort by it by passing the table and keys a, b,

+    -- otherwise just sort the keys

+    if order then

+        table.sort(keys, function(a,b) return order(t, a, b) end)

+    else

+        table.sort(keys)

+    end

+

+    -- return the iterator function

+    local i = 0

+    return function()

+        i = i + 1

+        if keys[i] then

+            return keys[i], t[keys[i]]

+        end

+    end

+end

+

+

+

+--- Prints usage instructions to stdout.

+-- If the optional `aMessage` is passed, output is prepended by message _and_

+-- redirected to stderr.

+local function usage(aMessage)

+	if aMessage then

+		io.output(io.stderr);

+		io.write(aMessage, "\n\n");

+	end

+	io.write(

+		"Usage: lua Generator.lua INPUTFILE OUTPUTFILE\n"..

+		"Converts the Minecraft blocks.json report format to the cuberite "..

+		"block type palette format.\n"..

+		"\n"..

+		"INPUTFILE and OUTPUTFILE must point to a valid path. INPUTFILE must "..

+		"be readable and OUTPUTFILE must be writable. Either can be replaced "..

+		"with `-` (dash character) to point to standard-input or -output.\n");

+	os.exit(message and 1 or 0);

+end

+

+

+

+

+

+--- Parses the JSON registry into a Lua table

+--[[ The returned array-table has the following format:

+{

+	{ id = 1, blockTypeName = "minecraft:stone", properties = {key = value, ...} },

+	...

+}

+--]]

+local function parseRegistry(aBlockRegistryJsonStr)

+	assert(type(aBlockRegistryJsonStr) == "string")

+

+	local lj = require("lunajson")

+	local input = lj.decode(aBlockRegistryJsonStr)

+	local registry = {}

+	local idx = 1

+	for blockTypeName, blockData in pairs(input) do

+		local function tchelper(before, underscore, first)

+			return before..first:upper()

+		end

+

+		blockTypeName = blockTypeName:gsub("(%a)([_:])(%a)", tchelper)

+		print(blockTypeName)

+

+		for _, state in pairs(blockData.states) do

+			registry[idx] = {

+				id = state.id,

+				blockTypeName = blockTypeName,

+				properties = state.properties,

+			}

+			idx = idx + 1

+		end

+	end

+	return registry

+end

+

+

+

+

+

+--- Serializes the properties from the JSON / array table format into a single output string

+-- Concatenates all properties with \t as the delimiting character

+local function serializeProperties(aProperties)

+	local res = {}

+	local idx = 1

+	for k, v in pairs(aProperties or {}) do

+		res[idx] = k

+		res[idx + 1] = v

+		idx = idx + 2

+	end

+	return table.concat(res, "\t")

+end

+

+

+

+

+

+--- Returns the prefix that is common for all block type names in the registry

+-- aRegistry is the parsed registry, as returned from parseRegistry()

+local function findCommonPrefix(aRegistryTable)

+	local prefix = aRegistryTable[1].blockTypeName

+	local len = string.len(prefix)

+	local sub = string.sub

+	for _, block in ipairs(aRegistryTable) do

+		while (sub(block.blockTypeName, 1, len) ~= prefix) do

+			len = len - 1

+			if (len == 0) then

+				return ""

+			end

+			prefix = sub(prefix, 1, len)

+		end

+	end

+	return prefix

+end

+

+

+

+

+

+-- Test whether the script is run in a path where it can load it's libraries

+if not(pcall(function() require("lunajson") end)) then

+	usage(

+		"Could not load required libraries, please run `Generator.lua` " ..

+		"within its directory and make sure to run `git submodule update`."

+	)

+end

+

+-- Check/Prepare CLI arguments

+local inpath, outpath = ...;

+inpath = inpath or "blocks.json"

+outpath = outpath or "base.btp.txt"

+if (inpath ~= "-") then

+	local handle, err = io.open(inpath, "r")

+	io.input(handle or usage(err))

+end

+if (outpath ~= "-") then

+	local handle, err = io.open(outpath, "w")

+	io.output(handle or usage(err))

+end

+

+aBlockRegistryJsonStr = io.input():read("*a")

+assert(type(aBlockRegistryJsonStr) == "string")

+

+local function makeTitleCase(input)

+	local function tchelper(before, underscore, first)

+		return before..first:upper()

+	end

+

+	if (input == "hay_block") then

+		return "HayBale"

+	elseif (input == "tnt") then

+		return "TNT"

+	end

+

+	input = input:gsub("(%a)(_)(%a)", tchelper)

+	input = input:gsub("(%a)(_)(%a)", tchelper)

+	return (input:gsub("^%l", string.upper))

+end

+

+local input = require("lunajson").decode(aBlockRegistryJsonStr)

+local registry = {}

+header = true

+

+for blockTypeName, blockData in pairs(input) do

+

+	local default = 0

+	local properties = {}

+	local states = {}

+

+	blockTypeName = makeTitleCase(blockTypeName:gsub("minecraft:", "", 1))

+

+	if blockData.properties ~= nil then

+		for property, values in pairs(blockData.properties) do

+

+			local firstProperty = values[1]

+			local property = makeTitleCase(property)

+			local propertyType

+

+			if firstProperty == "true" then

+				propertyType = "bool"

+			elseif tonumber(firstProperty) ~= nil then

+				propertyType = "unsigned char"

+			elseif (firstProperty == "north") or (firstProperty == "down") then -- Down is special for Hopper

+				propertyType = "eBlockFace"

+			else

+				propertyType = {}

+				for _, value in pairs(values) do

+					table.insert(propertyType, makeTitleCase(value))

+				end

+			end

+

+			if property ~= "Waterlogged" then

+				properties[property] = propertyType

+			end

+		end

+	end

+

+	for _, state in pairs(blockData.states) do

+

+		local stateForThisId = {}

+		states[state.id] = stateForThisId

+

+		if state.default ~= nil then

+			default = state.id

+		end

+

+		if state.properties ~= nil then

+			for property, value in pairs(state.properties) do

+

+				local property = makeTitleCase(property)

+

+				if (property == "Waterlogged") then

+					if (value == "true") then

+						states[state.id] = nil

+					end

+				elseif type(properties[property]) == "table" then

+					stateForThisId[property] = property .. "::" .. makeTitleCase(value)

+				elseif (properties[property] == "eBlockFace") then

+					local faceMapping = {

+						["north"] = "eBlockFace::BLOCK_FACE_ZM",

+						["south"] = "eBlockFace::BLOCK_FACE_ZP",

+						["west"] = "eBlockFace::BLOCK_FACE_XM",

+						["east"] = "eBlockFace::BLOCK_FACE_XP",

+						["up"] = "eBlockFace::BLOCK_FACE_YP",

+						["down"] = "eBlockFace::BLOCK_FACE_YM"

+					}

+					stateForThisId[property] = faceMapping[value]

+				else

+					stateForThisId[property] = value

+				end

+			end

+		end

+	end

+

+	registry[blockTypeName] = { default, properties, states }

+end

+

+local function writeBlocksEnum(registry)

+	if not header then

+		return

+	end

+

+	local blockTypeNames = {}

+	for blockTypeName, _ in spairs(registry) do

+		table.insert(blockTypeNames, blockTypeName)

+	end

+	io.write(

+		"\nenum class Type\n{\n\t",

+		table.concat(blockTypeNames, ",\n\t"),

+		"\n};"

+	)

+end

+

+local function writeTypeGetter(registry)

+	io.write("\nenum Type Type(short ID)")

+

+	if header then

+		io.write(";")

+		return

+	end

+

+	io.write("\n{\n\tswitch(ID)\n\t{\n\t")

+

+	local lastBlockIndex = 0

+	for _, _ in pairs(registry) do

+		lastBlockIndex = lastBlockIndex + 1

+	end

+

+	local index = 0

+	local previousTypeName, _ = spairs(registry)()

+	for blockTypeName, blockData in spairs(registry) do

+		if (previousTypeName ~= blockTypeName) then

+			io.write(" return Type::", previousTypeName, ";\n\t")

+			previousTypeName = blockTypeName

+		end

+

+		index = index + 1

+		if (index == lastBlockIndex) then

+			io.write("default: return Type::", blockTypeName, ";\n\t}\n}")

+			return

+		end

+

+		for stateId, _ in spairs(blockData[3]) do

+			io.write("case ", stateId, ":")

+		end

+	end

+end

+

+local function writeTypeTester()

+	io.write("\nbool Is(short ID, enum Type Type)")

+	if header then

+		io.write(";")

+	else

+		io.write("\n{\n\treturn Block::Type(ID) == Type;\n}")

+	end

+end

+

+local function writeStateTypes(blockTypeName, properties)

+	if not header then

+		return

+	end

+

+	for property, propertyType in spairs(properties) do

+		if type(propertyType) == "table" then

+			io.write(

+				"\nenum class ", property, "\n{\n\t",

+				table.concat(propertyType, ",\n\t"),

+				"\n};"

+			)

+		end

+	end

+end

+

+local function writeDefaultSerialiser(blockTypeName, default)

+	io.write("\nshort ", blockTypeName, "()")

+	if header then

+		io.write(";")

+	else

+		io.write("\n{\n\treturn ", default, ";\n}")

+	end

+end

+

+local function adjustMaybeEnumType(property, propertyType)

+	if type(propertyType) == "table" then

+		return "enum " .. property

+	else

+		return propertyType

+	end

+end

+

+local function writeSerialisers(blockTypeName, properties, states)

+	if not header then

+		local argCount = 0

+		for property, _ in spairs(properties) do

+			argCount = argCount + 1

+		end

+		return argCount

+	end

+

+	local argCount = 0

+	local arguments = {}

+	for property, propertyType in spairs(properties) do

+		argCount = argCount + 1

+		local adjustedType = adjustMaybeEnumType(property, propertyType)

+		table.insert(arguments, adjustedType .. " " .. property)

+	end

+

+	io.write(

+		"\nconstexpr short ", blockTypeName,

+		"(", table.concat(arguments, ", "), ")\n{"

+	)

+

+	local lastStateIndex = 0

+	for _, _ in pairs(states) do

+		lastStateIndex = lastStateIndex + 1

+	end

+

+	local index = 0

+	for stateId, values in spairs(states) do

+		local equalities = {}

+		for property, value in spairs(values) do

+			if (value == "true") then

+				table.insert(equalities, property)

+			elseif (value == "false") then

+				table.insert(equalities, "!" .. property)

+			else

+				table.insert(equalities, property .. " == " .. value)

+			end

+		end

+

+		index = index + 1

+		if (index == lastStateIndex) then

+			io.write("\n\treturn ", stateId, ";\n}")

+			return argCount

+		else

+			io.write("\n\tif (", table.concat(equalities, " && "), ") return ", stateId, ";")

+		end

+	end

+end

+

+local function writeGetters(properties, states)

+	for property, propertyType in spairs(properties) do

+		local adjustedType = adjustMaybeEnumType(property, propertyType)

+		io.write("\n", adjustedType, " ", property, "(short ID)")

+

+		if header then

+			io.write(";")

+		else

+			io.write("\n{\n\tswitch(ID)\n\t{\n\t")

+

+			local valuesArray = {}

+			local lastValuesArrayIndex = 0

+

+			for stateId, propertyValuePairs in spairs(states) do

+				if (valuesArray[propertyValuePairs[property]] == nil) then

+					valuesArray[propertyValuePairs[property]] = {}

+					lastValuesArrayIndex = lastValuesArrayIndex + 1

+				end

+				table.insert(valuesArray[propertyValuePairs[property]], stateId)

+			end

+

+			local index = 0

+			local previousValue, _ = spairs(valuesArray)()

+			for value, stateIds in spairs(valuesArray) do

+				index = index + 1

+				if (index == lastValuesArrayIndex) then

+					io.write("default: return ", value, ";\n\t}\n}")

+				else

+					for _, stateId in spairs(stateIds) do

+						io.write("case ", stateId, ": ")

+					end

+					io.write("return ", value, ";\n\t")

+				end

+			end

+		end

+	end

+end

+

+local function writeBlocks(registry)

+	io.write("\nnamespace Block\n{")

+	writeBlocksEnum(registry)

+	writeTypeGetter(registry)

+	writeTypeTester()

+

+	for blockTypeName, blockData in spairs(registry) do

+		io.write("\nnamespace ", blockTypeName, "\n{")

+

+		local default = blockData[1]

+		local properties = blockData[2]

+		local states = blockData[3]

+

+		writeStateTypes(blockTypeName, properties)

+		if (writeSerialisers(blockTypeName, properties, states) > 0) then

+			writeDefaultSerialiser(blockTypeName, default)

+		end

+		writeGetters(properties, states)

+

+		io.write("\n}")

+	end

+	io.write("\n}")

+end

+

+local function writeGlobalPalette(registry)

+	io.write("UInt32 FromBlock(short ID)\n{\n\tusing namespace Block;\n\n\tswitch (ID)\n\t{")

+	for blockTypeName, blockData in spairs(registry) do

+		local states = blockData[3]

+		for stateId, propertyValuePairs in spairs(states) do

+			local values = {}

+			for property, value in spairs(propertyValuePairs) do

+				if (value == "true") or (value == "false") or (tonumber(value) ~= nil) or (string.sub(value,1,string.len("eBlockFace"))=="eBlockFace") then

+					table.insert(values, value)

+				else

+					table.insert(values, blockTypeName .. "::" .. value)

+				end

+			end

+			io.write(

+				"\n\tcase ", blockTypeName, "::", blockTypeName, "(", table.concat(values, ","),

+				"): return ", stateId, ";"

+			)

+		end

+	end

+	io.write("\n\tdefault: return 0;\n\t}\n}")

+end

+

+if false then

+	writeBlocks(registry)

+else

+	writeGlobalPalette(registry)

+end

diff --git a/Tools/BlockTypePaletteGenerator/ItemGenerator.lua b/Tools/BlockTypePaletteGenerator/ItemGenerator.lua
new file mode 100644
index 000000000..5eff87603
--- /dev/null
+++ b/Tools/BlockTypePaletteGenerator/ItemGenerator.lua
@@ -0,0 +1,222 @@
+-- Generator.lua

+

+--[[

+Crafts an intermediate block palette format to be read by Cuberite.

+It processes the blocks.json report file (https://wiki.vg/Data_Generators)

+into a file that can be loaded into a BlockTypePalette (and is to be stored

+as Server/Protocol/<version>/base.btp.txt).

+

+The output format is the regular TSV BlockTypePalette, described in the

+$/src/BlockTypePalette.h file.

+--]]

+

+

+

+

+-- Allow Lua to load libraries in our subfolder:

+package.path = 'lib/lunajson/src/?.lua;' .. package.path;

+

+

+

+

+function spairs(t, order)

+    -- collect the keys

+    local keys = {}

+    for k in pairs(t) do keys[#keys+1] = k end

+

+    -- if order function given, sort by it by passing the table and keys a, b,

+    -- otherwise just sort the keys

+    if order then

+        table.sort(keys, function(a,b) return order(t, a, b) end)

+    else

+        table.sort(keys)

+    end

+

+    -- return the iterator function

+    local i = 0

+    return function()

+        i = i + 1

+        if keys[i] then

+            return keys[i], t[keys[i]]

+        end

+    end

+end

+

+

+

+--- Prints usage instructions to stdout.

+-- If the optional `aMessage` is passed, output is prepended by message _and_

+-- redirected to stderr.

+local function usage(aMessage)

+	if aMessage then

+		io.output(io.stderr);

+		io.write(aMessage, "\n\n");

+	end

+	io.write(

+		"Usage: lua Generator.lua INPUTFILE OUTPUTFILE\n"..

+		"Converts the Minecraft blocks.json report format to the cuberite "..

+		"block type palette format.\n"..

+		"\n"..

+		"INPUTFILE and OUTPUTFILE must point to a valid path. INPUTFILE must "..

+		"be readable and OUTPUTFILE must be writable. Either can be replaced "..

+		"with `-` (dash character) to point to standard-input or -output.\n");

+	os.exit(message and 1 or 0);

+end

+

+

+

+

+

+--- Parses the JSON registry into a Lua table

+--[[ The returned array-table has the following format:

+{

+	{ id = 1, blockTypeName = "minecraft:stone", properties = {key = value, ...} },

+	...

+}

+--]]

+local function parseRegistry(aBlockRegistryJsonStr)

+	assert(type(aBlockRegistryJsonStr) == "string")

+

+	local lj = require("lunajson")

+	local input = lj.decode(aBlockRegistryJsonStr)

+	local registry = {}

+	local idx = 1

+	for blockTypeName, blockData in pairs(input) do

+		local function tchelper(before, underscore, first)

+			return before..first:upper()

+		end

+

+		blockTypeName = blockTypeName:gsub("(%a)([_:])(%a)", tchelper)

+		print(blockTypeName)

+

+		for _, state in pairs(blockData.states) do

+			registry[idx] = {

+				id = state.id,

+				blockTypeName = blockTypeName,

+				properties = state.properties,

+			}

+			idx = idx + 1

+		end

+	end

+	return registry

+end

+

+

+

+

+

+--- Serializes the properties from the JSON / array table format into a single output string

+-- Concatenates all properties with \t as the delimiting character

+local function serializeProperties(aProperties)

+	local res = {}

+	local idx = 1

+	for k, v in pairs(aProperties or {}) do

+		res[idx] = k

+		res[idx + 1] = v

+		idx = idx + 2

+	end

+	return table.concat(res, "\t")

+end

+

+

+

+

+

+--- Returns the prefix that is common for all block type names in the registry

+-- aRegistry is the parsed registry, as returned from parseRegistry()

+local function findCommonPrefix(aRegistryTable)

+	local prefix = aRegistryTable[1].blockTypeName

+	local len = string.len(prefix)

+	local sub = string.sub

+	for _, block in ipairs(aRegistryTable) do

+		while (sub(block.blockTypeName, 1, len) ~= prefix) do

+			len = len - 1

+			if (len == 0) then

+				return ""

+			end

+			prefix = sub(prefix, 1, len)

+		end

+	end

+	return prefix

+end

+

+

+

+

+

+-- Test whether the script is run in a path where it can load it's libraries

+if not(pcall(function() require("lunajson") end)) then

+	usage(

+		"Could not load required libraries, please run `Generator.lua` " ..

+		"within its directory and make sure to run `git submodule update`."

+	)

+end

+

+-- Check/Prepare CLI arguments

+local inpath, outpath = ...;

+inpath = inpath or "blocks.json"

+outpath = outpath or "base.btp.txt"

+if (inpath ~= "-") then

+	local handle, err = io.open(inpath, "r")

+	io.input(handle or usage(err))

+end

+if (outpath ~= "-") then

+	local handle, err = io.open(outpath, "w")

+	io.output(handle or usage(err))

+end

+

+aBlockRegistryJsonStr = io.input():read("*a")

+assert(type(aBlockRegistryJsonStr) == "string")

+

+local function makeTitleCase(input)

+	local function tchelper(before, underscore, first)

+		return before..first:upper()

+	end

+

+	input = input:gsub("(%a)(_)(%a)", tchelper)

+	return (input:gsub("^%l", string.upper))

+end

+

+local input = require("lunajson").decode(aBlockRegistryJsonStr)

+local registry = {}

+header = true

+

+for itemName, id in spairs(input["minecraft:custom_stat"].entries) do

+	itemName = itemName:gsub("minecraft:", "", 1)

+	registry[itemName] = id.protocol_id

+end

+

+local function writeItems(registry)

+	io.write()

+

+	local names = {}

+	for itemName, _ in spairs(registry) do

+		table.insert(names, makeTitleCase(itemName))

+	end

+

+	io.write("\nenum class Statistic\n{\n", table.concat(names, ",\n"), "\n};")

+end

+

+local function writeGlobalPalette(registry)

+	io.write("UInt32 FromItem(Statistic ID)\n{\nswitch (ID)\n{")

+	for itemName, id in spairs(registry) do

+		io.write("\ncase Statistic::", makeTitleCase(itemName), ": return ", id, ";")

+	end

+	io.write("\ndefault: return 0;\n}\n}")

+end

+

+local function writeReverseGlobalPalette(registry)

+	io.write("Item ToStatistic(UInt32 ID)\n{\nswitch (ID)\n{")

+	for itemName, id in spairs(registry) do

+		io.write("\ncase ", id, ": return Item::", makeTitleCase(itemName), ";")

+	end

+	io.write("\ndefault: return Statistic::Air;\n}\n}")

+end

+

+if true then

+	writeItems(registry)

+else

+	writeGlobalPalette(registry)

+	io.write("\n\n")

+	writeReverseGlobalPalette(registry)

+end

diff --git a/Tools/BlockTypePaletteGenerator/convert.py b/Tools/BlockTypePaletteGenerator/convert.py
new file mode 100644
index 000000000..1f1080271
--- /dev/null
+++ b/Tools/BlockTypePaletteGenerator/convert.py
@@ -0,0 +1,19 @@
+input = """"""

+

+def do(name, index, value):

+	trues = [name + "::East::Low", name + "::North::Low", name + "::South::Low", "true", name + "::West::Low"]

+	falses = [name + "::East::None", name + "::North::None", name + "::South::None", "false", name + "::West::None"]

+	if value == "true":

+		return trues[index]

+	return falses[index]

+

+for line in input.split("\n"):

+	if not "Wall(" in line:

+		print(line)

+		continue

+	line = line.strip()

+	start = line.find("(") + 1

+	end = line.find(")", start)

+	name = line.split("::")[0].split(" ")[1]

+	result = ",".join(do(name, index, value) for index, value in enumerate(line[start:end].split(",")))

+	print(line[0:start] + result + line[end:])