automate registry data extraction

build_registries.js

@@ -0,0 +1,227 @@
+const fs = require("fs/promises");
+const path = require("path");
+
+// Extract item and block data from registry dump
+async function extractItemsAndBlocks () {
+
+  // Block network IDs are defined in their own JSON file
+  const blockSource = JSON.parse(await fs.readFile(`${__dirname}/notchian/generated/reports/blocks.json`, "utf8"));
+  // Items don't seem to have network IDs outside of registries.json
+  const itemSource = JSON.parse(await fs.readFile(`${__dirname}/notchian/generated/reports/registries.json`, "utf8"))["minecraft:item"].entries;
+
+  // Sort blocks by their network ID
+  // Since we're only storing 256 blocks, this prioritizes the "common" ones first
+  const sortedBlocks = Object.entries(blockSource);
+  sortedBlocks.sort((a, b) => {
+    const aState = a[1].states.find(c => c.default);
+    if (!aState) return 1;
+    const bState = b[1].states.find(c => c.default);
+    if (!bState) return -1;
+    return aState.id - bState.id;
+  });
+
+  // Create name-id pair objects for easier parsing
+  const blocks = {}, items = {};
+
+  for (const entry of sortedBlocks) {
+    const defaultState = entry[1].states.find(c => c.default);
+    if (!defaultState) continue;
+    blocks[entry[0].replace("minecraft:", "")] = defaultState.id;
+  }
+
+  for (const item in itemSource) {
+    items[item.replace("minecraft:", "")] = itemSource[item].protocol_id;
+  }
+
+  /**
+   * Create a block network ID palette.
+   * The goal is to pack as many meaningful blocks into 256 IDs as
+   * possible. For this, we only include blocks that have corresponding
+   * items, outside of some exceptions.
+   */
+  const palette = {};
+  const exceptions = [ "air", "water", "lava" ];
+
+  // While we're at it, map block IDs to item IDs
+  const mapping = [];
+
+  for (const block in blocks) {
+    if (!(block in items) && !exceptions.includes(block)) continue;
+    palette[block] = blocks[block];
+    mapping.push(items[block] || 0);
+    if (mapping.length === 256) break;
+  }
+
+  return { blocks, items, palette, mapping };
+
+}
+
+// Write an integer as a VarInt
+function writeVarInt (value) {
+  const bytes = [];
+  while (true) {
+    if ((value & ~0x7F) === 0) {
+      bytes.push(value);
+      return Buffer.from(bytes);
+    }
+    bytes.push((value & 0x7F) | 0x80);
+    value >>>= 7;
+  }
+}
+
+// Scan directory recursively to find all JSON files
+async function scanDirectory (basePath, currentPath = "") {
+  const entries = {};
+  const items = await fs.readdir(path.join(basePath, currentPath), { withFileTypes: true });
+
+  for (const item of items) {
+    const relativePath = path.join(currentPath, item.name);
+    if (item.isDirectory()) {
+      const subEntries = await scanDirectory(basePath, relativePath);
+      Object.assign(entries, subEntries);
+    } else if (item.name.endsWith(".json")) {
+      const dirPath = path.dirname(relativePath);
+      const registryName = dirPath === "." ? "" : dirPath;
+      const entryName = path.basename(item.name, ".json");
+
+      if (!entries[registryName]) {
+        entries[registryName] = [];
+      }
+      entries[registryName].push(entryName);
+    }
+  }
+
+  return entries;
+}
+
+// Serialize a single registry
+function serializeRegistry (name, entries) {
+  const parts = [];
+
+  // Packet ID for Registry Data
+  parts.push(Buffer.from([0x07]));
+
+  // Registry name
+  const nameBuf = Buffer.from(name, "utf8");
+  parts.push(writeVarInt(nameBuf.length));
+  parts.push(nameBuf);
+
+  // Entry count
+  parts.push(writeVarInt(entries.length));
+
+  // Serialize entries
+  for (const entryName of entries) {
+    const entryBuf = Buffer.from(entryName, "utf8");
+    parts.push(writeVarInt(entryBuf.length));
+    parts.push(entryBuf);
+    parts.push(Buffer.from([0x00]));
+  }
+
+  // Combine all parts
+  const fullData = Buffer.concat(parts);
+
+  // Prepend packet length
+  const lengthBuf = writeVarInt(fullData.length);
+
+  return Buffer.concat([lengthBuf, fullData]);
+}
+
+// Convert to C-style hex byte array string
+function toCArray (buffer) {
+  const hexBytes = [...buffer].map(b => `0x${b.toString(16).padStart(2, "0")}`);
+  const lines = [];
+  for (let i = 0; i < hexBytes.length; i += 12) {
+    lines.push("  " + hexBytes.slice(i, i + 12).join(", "));
+  }
+  return lines.join(",\n");
+}
+
+const requiredRegistries = [
+  "dimension_type",
+  "cat_variant",
+  "chicken_variant",
+  "cow_variant",
+  "frog_variant",
+  "painting_variant",
+  "pig_variant",
+  "wolf_sound_variant",
+  "wolf_variant",
+  "damage_type",
+  "worldgen/biome"
+];
+
+async function convert () {
+
+  const inputPath = __dirname + "/notchian/generated/data/minecraft";
+  const outputPath = __dirname + "/src/registries.c";
+  const headerPath = __dirname + "/src/registries.h";
+
+  const registries = await scanDirectory(inputPath);
+  const buffers = [];
+
+  for (const registry of requiredRegistries) {
+    if (!(registry in registries)) {
+      console.error(`Missing required registry "${registry}"!`);
+      return;
+    }
+    buffers.push(serializeRegistry(registry, registries[registry]));
+  }
+
+  const itemsAndBlocks = await extractItemsAndBlocks();
+
+  const output = Buffer.concat(buffers);
+  const cArray = toCArray(output);
+  const sourceCode = `\
+#include <stdint.h>
+#include "registries.h"
+
+// Binary contents of required "Registry Data" packets
+uint8_t registries_bin[] = {
+${cArray}
+};
+
+// Block palette
+uint16_t block_palette[] = { ${Object.values(itemsAndBlocks.palette).join(", ")} };
+// Block-to-item mapping
+uint16_t B_to_I[] = { ${itemsAndBlocks.mapping.join(", ")} };
+// Item-to-block mapping
+uint8_t I_to_B (uint16_t item) {
+  switch (item) {
+    ${itemsAndBlocks.mapping.map((c, i) => c ? `case ${c}: return ${i};\n    ` : "").join("")}
+    default: break;
+  }
+  return 0;
+}
+`;
+
+  const headerCode = `\
+#ifndef H_REGISTRIES
+#define H_REGISTRIES
+
+#include <stdint.h>
+
+extern uint8_t registries_bin[${output.length}];
+
+extern uint16_t block_palette[256]; // Block palette
+extern uint16_t B_to_I[256]; // Block-to-item mapping
+uint8_t I_to_B (uint16_t item); // Item-to-block mapping
+
+// Block identifiers
+${Object.keys(itemsAndBlocks.palette).map((c, i) => `#define B_${c} ${i}`).join("\n")}
+
+// Item identifiers
+${Object.entries(itemsAndBlocks.items).map(c => `#define I_${c[0]} ${c[1]}`).join("\n")}
+
+// Biome identifiers
+${registries["worldgen/biome"].map((c, i) => `#define W_${c} ${i}`).join("\n")}
+
+#endif
+`;
+
+  await fs.writeFile(outputPath, sourceCode);
+  await fs.writeFile(headerPath, headerCode);
+  console.log("Done. Wrote to `registries.c` and `registries.h`");
+
+}
+
+convert().catch(console.error);