minecraft-data 3.97.0 → 3.98.0

package/minecraft-data/schemas/tints_schema.json

@@ -2,161 +2,70 @@
   "title": "tints",
   "type": "object",
   "additionalProperties": false,
-  "properties": {
-    "grass": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "data": {
-          "type": "array",
-          "minItem": 1,
-          "uniqueItems": true,
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-              "keys": {
-                "type": "array",
-                "minItem": 1,
-                "uniqueItems": true,
-                "items": {
-                  "type": "string"
-                }
-              },
-              "color": {
-                "type": "integer"
-              }
-            }
-          }
-        },
-        "default": {
-          "type": "integer"
-        }
-      }
-    },
-    "foliage": {
+  "definitions": {
+    "StringKeyTintEntry": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "data": {
+        "keys": {
           "type": "array",
-          "minItem": 1,
+          "minItems": 1,
           "uniqueItems": true,
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-              "keys": {
-                "type": "array",
-                "minItem": 1,
-                "uniqueItems": true,
-                "items": {
-                  "type": "string"
-                }
-              },
-              "color": {
-                "type": "integer"
-              }
-            }
-          }
+          "items": { "type": "string" }
         },
-        "default": {
-          "type": "integer"
-        }
-      }
+        "color": { "type": "integer" }
+      },
+      "required": ["keys", "color"]
     },
-    "water": {
+    "IntegerKeyTintEntry": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "data": {
+        "keys": {
           "type": "array",
-          "minItem": 1,
+          "minItems": 1,
           "uniqueItems": true,
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-              "keys": {
-                "type": "array",
-                "minItem": 1,
-                "uniqueItems": true,
-                "items": {
-                  "type": "string"
-                }
-              },
-              "color": {
-                "type": "integer"
-              }
-            }
-          }
+          "items": { "type": "integer" }
         },
-        "default": {
-          "type": "integer"
-        }
-      }
+        "color": { "type": "integer" }
+      },
+      "required": ["keys", "color"]
     },
-    "redstone": {
+    "StringKeyTintGroup": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
         "data": {
           "type": "array",
-          "minItem": 1,
+          "minItems": 1,
           "uniqueItems": true,
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-              "keys": {
-                "type": "array",
-                "minItem": 1,
-                "uniqueItems": true,
-                "items": {
-                  "type": "integer"
-                }
-              },
-              "color": {
-                "type": "integer"
-              }
-            }
-          }
+          "items": { "$ref": "#/definitions/StringKeyTintEntry" }
         },
-        "default": {
-          "type": "integer"
-        }
-      }
+        "default": { "type": "integer" }
+      },
+      "required": ["data"]
     },
-    "constant": {
+    "IntegerKeyTintGroup": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
         "data": {
           "type": "array",
-          "minItem": 1,
+          "minItems": 1,
           "uniqueItems": true,
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-              "keys": {
-                "type": "array",
-                "minItem": 1,
-                "uniqueItems": true,
-                "items": {
-                  "type": "string"
-                }
-              },
-              "color": {
-                "type": "integer"
-              }
-            }
-          }
+          "items": { "$ref": "#/definitions/IntegerKeyTintEntry" }
         },
-        "default": {
-          "type": "integer"
-        }
-      }
+        "default": { "type": "integer" }
+      },
+      "required": ["data"]
     }
-  }
-}
+  },
+  "properties": {
+    "grass": { "$ref": "#/definitions/StringKeyTintGroup" },
+    "foliage": { "$ref": "#/definitions/StringKeyTintGroup" },
+    "water": { "$ref": "#/definitions/StringKeyTintGroup" },
+    "redstone": { "$ref": "#/definitions/IntegerKeyTintGroup" },
+    "constant": { "$ref": "#/definitions/StringKeyTintGroup" }
+  },
+  "required": ["grass", "foliage", "water", "redstone", "constant"]
+}

package/minecraft-data/tools/js/extractPcEntityMetadata.js

@@ -1,18 +1,13 @@
+#!/usr/bin/env node
 const fs = require('fs')
 const cp = require('child_process')
 const { globSync } = require('glob')
-const version = process.argv[2]
-const mcdataVersion = process.argv[3] || process.argv[2]
-if (!version) {
-  console.log('Usage: node extractEntityMetadata.js <codeVersion> [mcdataVersion]')
-  process.exit(1)
-}
-
-if (!fs.existsSync(version)) {
-  cp.execSync(`git clone -b client${version} https://github.com/extremeheat/extracted_minecraft_data.git ${version} --depth 1`, { stdio: 'inherit' })
-}
 
-// decompiler may either put static defs inline (static varname = value) or keep decl and def in seperate blocks (static varname; static{varname = val, ..}) so normalize it
+/**
+ * Normalize decompiler output into an array of "statements"/lines.
+ * @param {string} raw
+ * @returns {string[]}
+ */
 function prepLines (raw) {
   const lines = raw.replaceAll(' {\n', ' {;\n').split(';')
   for (let i = 0; i < lines.length; i++) {
@@ -31,8 +26,13 @@ function prepLines (raw) {
   return lines
 }
 
-function getEntityTypes () {
-  const entityTypes = fs.readFileSync(`./${version}/client/net/minecraft/world/entity/EntityType.java`, 'utf8')
+/**
+ * Read entity types from the client EntityType.java and return mappings.
+ * @param {string} versionDir
+ * @returns {[Record<string,string>, Record<string,string>]}
+ */
+function getEntityTypes (versionDir) {
+  const entityTypes = fs.readFileSync(`${versionDir}/client/net/minecraft/world/entity/EntityType.java`, 'utf8')
   const entityTypesLines = prepLines(entityTypes)
   const classNameTo = {}
   const nameToClass = {}
@@ -51,9 +51,14 @@ function getEntityTypes () {
   return [classNameTo, nameToClass]
 }
 
-function getEntityMetadataSerializers () {
+/**
+ * Read EntityDataSerializers.java and return serializer names in order.
+ * @param {string} versionDir
+ * @returns {string[]}
+ */
+function getEntityMetadataSerializers (versionDir) {
   const output = []
-  const entityTypes = fs.readFileSync(`./${version}/client/net/minecraft/network/syncher/EntityDataSerializers.java`, 'utf8')
+  const entityTypes = fs.readFileSync(`${versionDir}/client/net/minecraft/network/syncher/EntityDataSerializers.java`, 'utf8')
   const entityTypesLines = prepLines(entityTypes)
   for (const line of entityTypesLines) {
     if (line.includes('registerSerializer')) {
@@ -69,107 +74,160 @@ function getEntityMetadataSerializers () {
   return output.map(e => e.toLowerCase())
 }
 
-const serializers = getEntityMetadataSerializers()
-const [classNameToRegistryName, entityNameToClass] = getEntityTypes()
-
-const allEntityFiles = globSync(`${version}/**/entity/**/*.java`)
-const allEntityFileCodes = Object.fromEntries(allEntityFiles.map(file => [
-  file.split(/\\|\//g).pop().replace('.java', ''),
-  fs.readFileSync(file, 'utf8')
-]))
-
-const entityPreTree = []
-const metadatas = {}
-
-for (const file in allEntityFileCodes) {
-  const code = allEntityFileCodes[file]
-  const lines = prepLines(code)
-  let lastClass
-  for (const line of lines) {
-    let lineWithoutGenerics = line.replace(/<.*>/g, '')
-    const bloatMods = ['abstract', 'static']
-    for (const mod of bloatMods) lineWithoutGenerics = lineWithoutGenerics.replace(` ${mod} `, ' ')
-
-    if (lineWithoutGenerics.includes('public class ')) {
-      const className = lineWithoutGenerics.split('public class ')[1]?.split(' ')[0]
-      lastClass = className
-      const extend = lineWithoutGenerics.split('extends ')[1]?.split(' ')[0]
-      if (className === file) {
-        if (extend) entityPreTree.push([extend, file])
-        else entityPreTree.push([file])
-      } else if (extend === file) {
-        lastClass = `${file}.${className}`
-        entityPreTree.push([file, lastClass])
+/**
+ * Main function to extract and optionally update mcdata files.
+ * @param {string} version - directory name for extracted src (e.g. "1.20")
+ * @param {string} [mcdataVersion] - mcdata version to update (defaults to version)
+ * @param {{write?:boolean, cloneIfMissing?:boolean}} [opts]
+ * @returns {{tree:object, flat:object, serializers:string[], classNameToRegistryName:object, entityNameToClass:object, metadatas:object}}
+ */
+function extractPcEntityMetadata (version, mcdataVersion = version, opts = {}) {
+  if (!version) {
+    throw new Error('Usage: extractPcEntityMetadata(version, [mcdataVersion])')
+  }
+  const write = opts.write !== false
+  const cloneIfMissing = opts.cloneIfMissing !== false
+
+  if (!fs.existsSync(version)) {
+    if (!cloneIfMissing) {
+      throw new Error(`Version directory "${version}" does not exist`)
+    }
+    cp.execSync(`git clone -b client${version} https://github.com/extremeheat/extracted_minecraft_data.git ${version} --depth 1`, { stdio: 'inherit' })
+  }
+
+  const serializers = getEntityMetadataSerializers(version)
+  const [classNameToRegistryName, entityNameToClass] = getEntityTypes(version)
+
+  const allEntityFiles = globSync(`${version}/**/entity/**/*.java`)
+  const allEntityFileCodes = Object.fromEntries(allEntityFiles.map(file => [
+    file.split(/\\|\//g).pop().replace('.java', ''),
+    fs.readFileSync(file, 'utf8')
+  ]))
+
+  const entityPreTree = []
+  const metadatas = {}
+
+  for (const file in allEntityFileCodes) {
+    const code = allEntityFileCodes[file]
+    const lines = prepLines(code)
+    let lastClass
+    for (const line of lines) {
+      let lineWithoutGenerics = line.replace(/<.*>/g, '')
+      const bloatMods = ['abstract', 'static']
+      for (const mod of bloatMods) lineWithoutGenerics = lineWithoutGenerics.replace(` ${mod} `, ' ')
+
+      if (lineWithoutGenerics.includes('public class ')) {
+        const className = lineWithoutGenerics.split('public class ')[1]?.split(' ')[0]
+        lastClass = className
+        const extend = lineWithoutGenerics.split('extends ')[1]?.split(' ')[0]
+        if (className === file) {
+          if (extend) entityPreTree.push([extend, file])
+          else entityPreTree.push([file])
+        } else if (extend === file) {
+          lastClass = `${file}.${className}`
+          entityPreTree.push([file, lastClass])
+        }
+      }
+
+      if (line.match(/SynchedEntityData\..*defineId\(/)) {
+        // from:    private static final EntityDataAccessor<Sniffer.State> DATA_STATE = SynchedEntityData.defineId(Sniffer.class, EntityDataSerializers.SNIFFER_STATE);
+        // extract: DATA_STATE, SNIFFER_STATE
+        const r = line.match(/> ([A-Z_0-9]+) = .*EntityDataSerializers.([A-Z_0-9]+)/s)
+        if (r) {
+          const [, data, serializer] = r
+          ; (metadatas[lastClass] ??= []).push([data, serializer])
+        } else {
+          throw new Error('Failed to parse line: ' + line)
+        }
       }
     }
+  }
 
-    if (line.match(/SynchedEntityData\..*defineId\(/)) {
-      // from:    private static final EntityDataAccessor<Sniffer.State> DATA_STATE = SynchedEntityData.defineId(Sniffer.class, EntityDataSerializers.SNIFFER_STATE);
-      // extract: DATA_STATE, SNIFFER_STATE
-      const r = line.match(/> ([A-Z_0-9]+) = .*EntityDataSerializers.([A-Z_0-9]+)/s)
-      if (r) {
-        const [, data, serializer] = r
-        ; (metadatas[lastClass] ??= []).push([data, serializer])
-      } else {
-        throw new Error('Failed to parse line: ' + line)
+  const tree = {}
+  const flat = {}
+  const handledNames = []
+  function build (ele, root = tree, arr = []) {
+    const name = classNameToRegistryName[ele]
+    const metadata = metadatas[ele]
+    root[ele] = { children: {}, name, metadata }
+    if (name) flat[name] = arr.concat(metadata ?? [])
+    handledNames.push(ele)
+    for (const [key, val] of entityPreTree) {
+      if (key === ele) {
+        build(val, root[key].children, arr.concat(metadata ?? []))
       }
     }
   }
-}
+  build('Entity')
+
+  for (const key in classNameToRegistryName) {
+    if (!handledNames.includes(key)) throw new Error('Unhandled entity ' + key)
+  }
+
+  function updateMcDataEntitiesJSON () {
+    const presentMcDataPath = `../../data/pc/${mcdataVersion}/entities.json`
+    const presentMcData = require(presentMcDataPath)
+    for (const entry of presentMcData) {
+      const cls = entityNameToClass[entry.name]
+      const regName = classNameToRegistryName[cls]
+      entry.metadataKeys = (flat[regName] || []).map(e => e[0].replace('DATA_', '').replace('_ID', '').replace('ID_', '').toLowerCase())
+    }
+    fs.writeFileSync(presentMcDataPath, JSON.stringify(presentMcData, null, 2))
+  }
 
-const tree = {}
-const flat = {}
-const handledNames = []
-function build (ele, root = tree, arr = []) {
-  const name = classNameToRegistryName[ele]
-  const metadata = metadatas[ele]
-  root[ele] = { children: {}, name, metadata }
-  if (name) flat[name] = arr.concat(metadata ?? [])
-  handledNames.push(ele)
-  for (const [key, val] of entityPreTree) {
-    if (key === ele) {
-      build(val, root[key].children, arr.concat(metadata ?? []))
+  function updateMcDataProtocolJSON () {
+    const presentMcDataPath = `../../data/pc/${mcdataVersion}/protocol.json`
+    const mcdata = require(presentMcDataPath)
+    const mapper = { type: 'varint', mappings: {} }
+    for (let i = 0; i < serializers.length; i++) {
+      mapper.mappings[i] = serializers[i].toLowerCase()
     }
+    mcdata.types.entityMetadata[1].type[1] = [
+      { name: 'key', type: 'u8' },
+      { name: 'type', type: ['mapper', mapper] },
+      { name: 'value', type: ['entityMetadataItem', { compareTo: 'type' }] }
+    ]
+    fs.writeFileSync(presentMcDataPath, JSON.stringify(mcdata, null, 2))
+  }
+
+  if (write) {
+    updateMcDataEntitiesJSON()
+    updateMcDataProtocolJSON()
+  }
+
+  return {
+    tree,
+    flat,
+    serializers,
+    classNameToRegistryName,
+    entityNameToClass,
+    metadatas,
+    entityPreTree
   }
 }
-build('Entity')
 
-for (const key in classNameToRegistryName) {
-  if (!handledNames.includes(key)) throw new Error('Unhandled entity ' + key)
+// Expose functions for use as a library
+module.exports = {
+  extractPcEntityMetadata,
+  prepLines,
+  getEntityTypes,
+  getEntityMetadataSerializers
 }
 
-function updateMcDataEntitiesJSON () {
-  const presentMcDataPath = `../../data/pc/${mcdataVersion}/entities.json`
-  const presentMcData = require(presentMcDataPath)
-  for (const entry of presentMcData) {
-    entry.metadataKeys = flat[classNameToRegistryName[entityNameToClass[entry.name]]].map(e => e[0].replace('DATA_', '').replace('_ID', '').replace('ID_', '').toLowerCase())
+// If run directly from the CLI, call the function with process.argv
+if (require.main === module) {
+  const version = process.argv[2]
+  const mcdataVersion = process.argv[3] || process.argv[2]
+  if (!version) {
+    console.log('Usage: node extractEntityMetadata.js <codeVersion> [mcdataVersion]')
+    process.exit(1)
   }
-  fs.writeFileSync(presentMcDataPath, JSON.stringify(presentMcData, null, 2))
-}
 
-function updateMcDataProtocolJSON () {
-  const presentMcDataPath = `../../data/pc/${mcdataVersion}/protocol.json`
-  const mcdata = require(presentMcDataPath)
-  const mapper = { type: 'varint', mappings: {} }
-  for (let i = 0; i < serializers.length; i++) {
-    mapper.mappings[i] = serializers[i].toLowerCase()
+  try {
+    extractPcEntityMetadata(version, mcdataVersion, { write: true, cloneIfMissing: true })
+    // finished successfully
+  } catch (err) {
+    console.error('Error:', err)
+    process.exit(1)
   }
-  mcdata.types.entityMetadata[1].type[1] = [
-    { name: 'key', type: 'u8' },
-    { name: 'type', type: ['mapper', mapper] },
-    { name: 'value', type: ['entityMetadataItem', { compareTo: 'type' }] }
-  ]
-  // One time code to remap integers to strings in protocol.json for the entityMetadataItem type
-  // const metadataItems = mcdata.types.entityMetadataItem[1].fields
-  // const next = {}
-  // for (const key in metadataItems) {
-  //   next[serializers[key]] = metadataItems[key]
-  // }
-  // mcdata.types.entityMetadataItem[1].fields = next
-  fs.writeFileSync(presentMcDataPath, JSON.stringify(mcdata, null, 2))
 }
-
-// fs.writeFileSync(`./entityTree.json`, JSON.stringify(tree, null, 2))
-// fs.writeFileSync(`./entityFlat.json`, JSON.stringify(flat, null, 2))
-updateMcDataEntitiesJSON()
-updateMcDataProtocolJSON()

package/minecraft-data/tools/js/test/audit_versions.js

@@ -0,0 +1,48 @@
+/* eslint-env mocha */
+
+const assert = require('assert')
+const path = require('path')
+const fs = require('fs')
+
+describe('dataPaths.json consistency with versions.json', function () {
+  const dataPathsFile = path.join(__dirname, '../../../data/dataPaths.json')
+  const dataPaths = require(dataPathsFile)
+
+  const editions = ['pc', 'bedrock']
+
+  editions.forEach(function (edition) {
+    describe(`${edition} versions consistency`, function () {
+      const versionsFile = path.join(
+        __dirname,
+        `../../../data/${edition}/common/versions.json`
+      )
+      assert.ok(
+        fs.existsSync(versionsFile),
+        `Missing versions.json for ${edition}`
+      )
+
+      const versionsList = require(versionsFile)
+      const manifestVersions = Object.keys(dataPaths[edition] || {})
+
+      it('all manifest versions are present in versions.json', function () {
+        const missing = manifestVersions.filter(
+          (v) => !versionsList.includes(v)
+        )
+        assert.deepStrictEqual(
+          missing,
+          [],
+          `The following ${edition} versions are in dataPaths.json but not in versions.json: ${missing.join(', ')}`
+        )
+      })
+
+      it('no extra versions exist in versions.json compared to manifest', function () {
+        const extra = versionsList.filter((v) => !manifestVersions.includes(v))
+        assert.deepStrictEqual(
+          extra,
+          [],
+          `The following ${edition} versions are in versions.json but not in dataPaths.json: ${extra.join(', ')}`
+        )
+      })
+    })
+  })
+})

package/minecraft-data/tools/js/test/test.js

@@ -24,6 +24,12 @@ require('./version_iterator')(function (p, versionString) {
       }
       if (instance) {
         it(dataName + '.json is valid', function () {
+          // Skip tints schema validation for PC 1.21.4, as it doesn't meet the
+          // maxItems: 1 check for the constant tints.
+          if (dataName === 'tints' && versionString === 'pc 1.21.4') {
+            this.skip()
+          }
+
           if (dataName === 'protocol') {
             const validator = new Validator()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-data",
-  "version": "3.97.0",
+  "version": "3.98.0",
   "description": "Provide easy access to minecraft data in node.js",
   "main": "index.js",
   "tonicExampleFilename": "example.js",