Update from Upstream

bom/build.gradle.kts

@@ -29,8 +29,6 @@ dependencies {
         // Libraries
         api(libs.gson)
         api(libs.jcTools)
-        // Path finding
-        api(libs.hydrazine)
 
         // Adventure, for user-interface
         api(libs.bundles.adventure)
@@ -45,10 +43,6 @@ dependencies {
         // Minestom Data (From MinestomDataGenerator)
         api(libs.minestomData)
 
-        // NBT parsing/manipulation/saving
-        api("io.github.jglrxavpok.hephaistos:common:${libs.versions.hephaistos.get()}")
-        api("io.github.jglrxavpok.hephaistos:gson:${libs.versions.hephaistos.get()}")
-
         // BStats
         api(libs.bstats.base)
     }

build.gradle.kts

@@ -10,7 +10,7 @@ plugins {
 
 group = "net.onelitefeather.microtus"
 
-version = System.getenv("TAG_VERSION") ?: "1.4.3-SNAPSHOT"
+version = System.getenv("TAG_VERSION") ?: "1.4.0-SNAPSHOT"
 
 allprojects {
     group = "net.onelitefeather.microtus"
@@ -58,7 +58,7 @@ tasks {
             addStringOption("-release", "21")
             // Links to external javadocs
             links("https://docs.oracle.com/en/java/javase/21/docs/api/")
-            links("https://jd.advntr.dev/api/${libs.versions.adventure.get()}/")
+            links("https://jd.adventure.kyori.net/api/${libs.versions.adventure.get()}/")
         }
     }
     withType<Zip> {
@@ -78,11 +78,11 @@ tasks {
 }
 
 dependencies {
-    // Testing Framework
-    testImplementation(project(mapOf("path" to ":testing")))
-    // Only here to ensure J9 module support for extensions and our classloaders
-    testCompileOnly(libs.mockito.core)
-
+    // Core dependencies
+    api(libs.slf4j)
+    api(libs.jetbrainsAnnotations)
+    api(libs.bundles.adventure)
+    implementation(libs.minestomData)
 
     // Logging
     implementation(libs.bundles.logging)
@@ -93,31 +93,22 @@ dependencies {
     implementation(libs.caffeine)
     api(libs.fastutil)
     implementation(libs.bundles.flare)
-
-    // Libraries
-    api(libs.gson)
-    implementation(libs.jcTools)
-    // Path finding
-    api(libs.hydrazine)
-
-    // Adventure, for user-interface
-    api(libs.bundles.adventure)
-
-    // Kotlin Libraries
-    api(libs.bundles.kotlin)
-
+    // BStats
+    api(libs.bstats.base)
+    // Maven
     api(libs.maven.resolver)
     api(libs.maven.connector)
     api(libs.maven.transport.http)
 
-    // Minestom Data (From MinestomDataGenerator)
-    implementation(libs.minestomData)
-
-    // NBT parsing/manipulation/saving
-    api("io.github.jglrxavpok.hephaistos:common:${libs.versions.hephaistos.get()}")
-    api("io.github.jglrxavpok.hephaistos:gson:${libs.versions.hephaistos.get()}")
+    // Libraries
+    api(libs.gson)
+    implementation(libs.jcTools)
 
-    // BStats
-    api(libs.bstats.base)
+    // Testing
+    testImplementation(libs.bundles.junit)
+    testImplementation(project(":testing"))
+    // Only here to ensure J9 module support for extensions and our classloaders
+    testCompileOnly(libs.mockito.core)
 }
 
+

code-generators/src/main/java/net/minestom/codegen/CodeGenerator.java

@@ -3,75 +3,128 @@
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonObject;
-import com.squareup.javapoet.AnnotationSpec;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.JavaFile;
-import com.squareup.javapoet.TypeSpec;
-import org.jetbrains.annotations.ApiStatus;
+import com.squareup.javapoet.*;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.lang.model.SourceVersion;
 import javax.lang.model.element.Modifier;
 import java.io.File;
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.List;
+import java.util.Locale;
 
-import static net.minestom.codegen.MinestomCodeGenerator.DEFAULT_INDENT;
-import static net.minestom.codegen.MinestomCodeGenerator.extractNamespaces;
-
-@ApiStatus.Internal
-public class CodeGenerator implements CodeExporter {
+public class CodeGenerator {
     protected static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
     private static final Logger LOGGER = LoggerFactory.getLogger(CodeGenerator.class);
+
     private final File outputFolder;
 
-    public CodeGenerator(@NotNull File outputFolder) {
+    public CodeGenerator(File outputFolder) {
         this.outputFolder = outputFolder;
     }
 
     public void generate(InputStream resourceFile, String packageName, String typeName, String loaderName, String generatedName) {
         if (resourceFile == null) {
-            LOGGER.error("Failed to find resource file for {}", typeName);
+            LOGGER.error("Failed to find resource file for " + typeName);
             return;
         }
         ClassName typeClass = ClassName.get(packageName, typeName);
         ClassName loaderClass = ClassName.get(packageName, loaderName);
 
-        JsonObject json = GSON.fromJson(new InputStreamReader(resourceFile), JsonObject.class);
+        JsonObject json;
+        json = GSON.fromJson(new InputStreamReader(resourceFile), JsonObject.class);
         ClassName materialsCN = ClassName.get(packageName, generatedName);
         // BlockConstants class
         TypeSpec.Builder blockConstantsClass = TypeSpec.interfaceBuilder(materialsCN)
                 // Add @SuppressWarnings("unused")
                 .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class).addMember("value", "$S", "unused").build())
                 .addJavadoc("Code autogenerated, do not edit!");
 
-        Map<String, String> replacementOptions = new HashMap<>();
-        replacementOptions.put("minecraft:", "");
-        replacementOptions.put(".", "_");
         // Use data
         json.keySet().forEach(namespace -> {
-            final String constantName = extractNamespaces(namespace, replacementOptions);
+            final String constantName = namespace
+                    .replace("minecraft:", "")
+                    .replace(".", "_")
+                    .toUpperCase(Locale.ROOT);
             blockConstantsClass.addField(
                     FieldSpec.builder(typeClass, constantName)
                             .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
                             .initializer(
+                                    // TypeClass.STONE = MaterialLoader.fromNamespaceId("minecraft:stone")
                                     "$T.get($S)",
                                     loaderClass,
                                     namespace
                             )
                             .build()
             );
         });
-        writeFile(
-                JavaFile.builder(packageName, blockConstantsClass.build())
-                        .indent(DEFAULT_INDENT)
+        writeFiles(
+                List.of(JavaFile.builder(packageName, blockConstantsClass.build())
+                        .indent("    ")
+                        .skipJavaLangImports(true)
+                        .build()),
+                outputFolder);
+    }
+
+    public void generateKeys(InputStream resourceFile, String packageName, String typeName, String generatedName) {
+        if (resourceFile == null) {
+            LOGGER.error("Failed to find resource file for " + typeName);
+            return;
+        }
+
+        ClassName typeClass = ClassName.bestGuess(packageName + "." + typeName); // Use bestGuess to handle nested class
+        ClassName registryKeyClass = ClassName.get("net.minestom.server.registry", "DynamicRegistry", "Key");
+        ParameterizedTypeName typedRegistryKeyClass = ParameterizedTypeName.get(registryKeyClass, typeClass);
+
+        JsonObject json;
+        json = GSON.fromJson(new InputStreamReader(resourceFile), JsonObject.class);
+        ClassName materialsCN = ClassName.get(packageName, generatedName);
+        // BlockConstants class
+        TypeSpec.Builder blockConstantsClass = TypeSpec.interfaceBuilder(materialsCN)
+                // Add @SuppressWarnings("unused")
+                .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class).addMember("value", "$S", "unused").build())
+                .addJavadoc("Code autogenerated, do not edit!");
+
+        // Use data
+        json.keySet().forEach(namespace -> {
+            String constantName = namespace
+                    .replace("minecraft:", "")
+                    .replace(".", "_")
+                    .toUpperCase(Locale.ROOT);
+            if (!SourceVersion.isName(constantName)) {
+                constantName = "_" + constantName;
+            }
+            blockConstantsClass.addField(
+                    FieldSpec.builder(typedRegistryKeyClass, constantName)
+                            .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+                            .initializer(
+                                    // TypeClass.STONE = NamespaceID.from("minecraft:stone")
+                                    "$T.of($S)",
+                                    registryKeyClass,
+                                    namespace
+                            )
+                            .build()
+            );
+        });
+        writeFiles(
+                List.of(JavaFile.builder(packageName, blockConstantsClass.build())
+                        .indent("    ")
                         .skipJavaLangImports(true)
-                        .build(),
-                outputFolder
-        );
+                        .build()),
+                outputFolder);
+    }
+
+    private void writeFiles(@NotNull List<JavaFile> fileList, File outputFolder) {
+        for (JavaFile javaFile : fileList) {
+            try {
+                javaFile.writeTo(outputFolder);
+            } catch (IOException e) {
+                LOGGER.error("An error occured while writing source code to the file system.", e);
+            }
+        }
     }
 }

code-generators/src/main/java/net/minestom/codegen/ConstantsGenerator.java

@@ -0,0 +1,82 @@
+package net.minestom.codegen;
+
+import com.google.gson.JsonObject;
+import com.squareup.javapoet.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.lang.model.element.Modifier;
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.List;
+
+public class ConstantsGenerator extends MinestomCodeGenerator {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ConstantsGenerator.class);
+    private final InputStream constantsFile;
+    private final File outputFolder;
+
+    public ConstantsGenerator(@Nullable InputStream constantsFile, @NotNull File outputFolder) {
+        this.constantsFile = constantsFile;
+        this.outputFolder = outputFolder;
+    }
+
+    @Override
+    public void generate() {
+        if (constantsFile == null) {
+            LOGGER.error("Failed to find constants.json.");
+            LOGGER.error("Stopped code generation for recipe types.");
+            return;
+        }
+        if (!outputFolder.exists() && !outputFolder.mkdirs()) {
+            LOGGER.error("Output folder for code generation does not exist and could not be created.");
+            return;
+        }
+
+        // Important classes we use alot
+        JsonObject constants = GSON.fromJson(new InputStreamReader(constantsFile), JsonObject.class);
+        ClassName minecraftConstantsCN = ClassName.get("net.minestom.server", "MinecraftConstants");
+        TypeSpec.Builder constantsInterface = TypeSpec.interfaceBuilder(minecraftConstantsCN)
+                .addJavadoc("AUTOGENERATED by " + getClass().getSimpleName());
+
+        constantsInterface.addField(FieldSpec.builder(String.class, "VERSION_NAME")
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+                .initializer("$S", constants.get("name").getAsString())
+                .build()
+        );
+        constantsInterface.addField(FieldSpec.builder(TypeName.INT, "PROTOCOL_VERSION")
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+                .initializer("$L", constants.get("protocol").getAsInt())
+                .build()
+        );
+        constantsInterface.addField(FieldSpec.builder(TypeName.INT, "DATA_VERSION")
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+                .initializer("$L", constants.get("world").getAsInt())
+                .build()
+        );
+        constantsInterface.addField(FieldSpec.builder(TypeName.INT, "RESOURCE_PACK_VERSION")
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+                .initializer("$L", constants.get("resourcepack").getAsInt())
+                .build()
+        );
+        constantsInterface.addField(FieldSpec.builder(TypeName.INT, "DATA_PACK_VERSION")
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+                .initializer("$L", constants.get("datapack").getAsInt())
+                .build()
+        );
+
+        // Write files to outputFolder
+        writeFiles(
+                List.of(
+                        JavaFile.builder("net.minestom.server", constantsInterface.build())
+                                .indent("    ")
+                                .skipJavaLangImports(true)
+                                .build()
+                ),
+                outputFolder
+        );
+    }
+
+}