Initial port to 26.1.2

.editorconfig

@@ -20,7 +20,7 @@ ij_json_keep_indents_on_empty_lines = false
 ij_json_keep_line_breaks = true
 ij_json_space_after_colon = true
 ij_json_space_after_comma = true
-ij_json_space_before_colon = true
+ij_json_space_before_colon = false
 ij_json_space_before_comma = false
 ij_json_spaces_within_braces = true
 ij_json_spaces_within_brackets = false

.github/workflows/build.yml

@@ -2,18 +2,24 @@ name: Build
 
 on: [ workflow_dispatch, pull_request, push ]
 
-env:
-  JAVA_VERSION: 21
-
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v4
 
+      - name: Extract Versions
+        id: versions
+        run: |
+          echo "java=$(grep -oP '(?<=java = )".*"' gradle/libs.versions.toml | cut -d '"' -f2)" >> "$GITHUB_OUTPUT"
+
       - name: Setup Java
-        run: echo "JAVA_HOME=$JAVA_HOME_${{ env.JAVA_VERSION }}_X64" >> "$GITHUB_ENV"
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: ${{ steps.versions.outputs.java }}
+          cache: gradle
 
       - name: Loom Cache
         uses: actions/cache@v4
@@ -30,8 +36,7 @@ jobs:
 
       - name: Build
         # Doesn't actually publish, as no secrets are passed in, just makes sure that publishing works
-        # Also generate the mod jars for the test job
-        run: ./gradlew remapTestModJar publish --no-daemon
+        run: ./gradlew publish --no-daemon
 
       - name: Capture Build Artifacts
         uses: actions/upload-artifact@v4
@@ -41,44 +46,6 @@ jobs:
             common/build/libs/
             fabric/build/libs/
             neoforge/build/libs/
-            vanillinFabric/build/libs/
-            vanillinNeoForge/build/libs/
-
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        loader: [ neoforge, fabric ]
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Download build artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: Artifacts
-
-      - name: Setup Environment Variables
-        run: |
-          echo "MINECRAFT_VERSION=$(grep '^minecraft_version =' gradle.properties | cut -d'=' -f2 | tr -d ' ')" >> "$GITHUB_ENV"
-          echo "FABRIC_API_VERSION=$(grep '^fabric_api_version =' gradle.properties | cut -d'=' -f2 | tr -d ' ' | sed 's/+.*//')" >> "$GITHUB_ENV"
-
-      - name: Move Test Mod and Flywheel into run/mods
-        # We don't want to recreate the jar name formatting so glob everything over then remove the sources and javadoc jars
-        run: |
-          mkdir -p run/mods
-          cp ${{ matrix.loader }}/build/libs/*.jar run/mods
-          rm -f run/mods/*-sources.jar run/mods/*-javadoc.jar
-
-      # Lock to a specific commit, it would be bad if the tag is re-pushed with unwanted changes
-      - name: Run the MC client
-        uses: 3arthqu4ke/mc-runtime-test@e72f8fe1134aabf6fc749a2a8c09bb56dd7d283e
-        with:
-          mc: ${{ env.MINECRAFT_VERSION }}
-          modloader: ${{ matrix.loader }}
-          regex: .*${{ matrix.loader }}.*
-          mc-runtime-test: none
-          java: ${{ env.JAVA_VERSION }}
-          fabric-api: ${{ matrix.loader == 'fabric' && env.FABRIC_API_VERSION || 'none' }}
+            vanillin/common/build/libs/
+            vanillin/fabric/build/libs/
+            vanillin/neoforge/build/libs/

.gitignore

@@ -6,6 +6,7 @@ build/
 gradle-app.setting
 out/
 logs/
+.kotlin/
 
 ## IntelliJ IDEA
 
@@ -64,5 +65,4 @@ docs/*.local
 # Other
 .DS_Store
 mcmodsrepo
-src/*/generatedPackageInfos/
-*/src/*/generatedPackageInfos/
+**/src/**/generatedPackageInfos/

Jenkinsfile

@@ -11,7 +11,7 @@ pipeline {
     }
 
     tools {
-        jdk "jdk-21"
+        jdk "jdk-25"
     }
 
     stages {
@@ -24,8 +24,7 @@ pipeline {
                 sh './gradlew clean'
 
                 withCredentials([
-                    // build_secrets is parsed in SubprojectExtension#loadSecrets
-                    file(credentialsId: 'build_secrets', variable: 'ORG_GRADLE_PROJECT_secretFile'),
+                    usernamePassword(credentialsId: 'maven_secrets', usernameVariable: 'MAVEN_USERNAME', passwordVariable: 'MAVEN_PASSWORD')
                 ]) {
                     echo 'Building project.'
                     // Sometimes builds freeze, so wrap in a timeout.
@@ -77,8 +76,7 @@ pipeline {
                 sh './gradlew clean'
 
                 withCredentials([
-                    // build_secrets is parsed in SubprojectExtension#loadSecrets
-                    file(credentialsId: 'build_secrets', variable: 'ORG_GRADLE_PROJECT_secretFile'),
+                    usernamePassword(credentialsId: 'maven_secrets', usernameVariable: 'MAVEN_USERNAME', passwordVariable: 'MAVEN_PASSWORD')
                 ]) {
                     echo 'Building project for release.'
                     // Sometimes builds freeze, so wrap in a timeout.

build-logic/build.gradle.kts

@@ -0,0 +1,22 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    gradlePluginPortal()
+    maven("https://maven.fabricmc.net")
+}
+
+gradlePlugin {
+    plugins {
+        create("flywheelGradlePlugin") {
+            id = libs.plugins.flywheel.gradle.get().toString()
+            implementationClass = "dev.engine_room.gradle.FlywheelGradlePlugin"
+        }
+    }
+}
+
+dependencies {
+    implementation(libs.fabric.loom)
+    implementation(libs.mdg)
+}

build-logic/settings.gradle.kts

@@ -0,0 +1,9 @@
+rootProject.name = "build-logic"
+
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}

build-logic/src/main/kotlin/configure-base.gradle.kts

@@ -0,0 +1,113 @@
+import dev.engine_room.gradle.getProperty
+import dev.engine_room.gradle.versionOf
+
+plugins {
+    java
+    `maven-publish`
+}
+
+val modId = parent!!.name
+val modName = getProperty("${modId}_name")
+val modVersion = getProperty("${modId}_version")
+val modDescription = getProperty("${modId}_description")
+
+val modLoader = project.name.split('-').last()
+
+val buildNumber: Provider<String> = providers.environmentVariable("RELEASE")
+    .map { it.contentEquals("false", true) }
+    .flatMap { dev ->
+        providers.environmentVariable("BUILD_NUMBER")
+            .filter { dev }
+    }
+
+// Only return the first 2 components of the minecraft version, ignoring the hotfix component
+val artifactMinecraftVersion = versionOf("minecraft")
+    .split('.')
+    .take(2)
+    .joinToString(".")
+
+val mavenBuildSuffix = buildNumber.map { "-$it" }.getOrElse("")
+val semverBuildSuffix = buildNumber.map { "+build.${it}" }.getOrElse("")
+
+ext["mod_id"] = modId
+ext["mod_name"] = modName
+
+group = "${getProperty("base_group")}.${modId}"
+// ${1.0.0}-mc${26.1}${-9999}
+version = "${modVersion}-mc${artifactMinecraftVersion}${mavenBuildSuffix}"
+
+// ${1.0.0}${+build.9999 OR -9999}
+val loaderModVersion = modVersion + if (modLoader == "fabric") semverBuildSuffix else mavenBuildSuffix
+
+val authors = getProperty("mod_authors")
+tasks.processResources {
+    fun prop(name: String) = Pair(name, getProperty(name))
+    fun versionProp(name: String) = Pair("${name}_version", versionOf(name))
+
+    val properties = mapOf(
+        "mod_id" to modId,
+        "mod_name" to modName,
+        "mod_version" to loaderModVersion,
+        "mod_description" to modDescription,
+        "mod_authors" to authors,
+        "mod_authors_json" to authors.formatForJson(),
+        prop("mod_homepage"),
+        prop("mod_sources"),
+        prop("mod_issues"),
+        prop("mod_license"),
+        versionProp("minecraft"),
+        versionProp("fabric_api"),
+        versionProp("fabric_loader"),
+        versionProp("neoforge"),
+        versionProp("java"),
+        prop("flywheel_maven_version_range"),
+        prop("flywheel_semver_version_range"),
+    )
+
+    inputs.properties(properties)
+
+    filesMatching(setOf("fabric.mod.json", "META-INF/neoforge.mods.toml")) {
+        expand(properties)
+    }
+}
+
+tasks.withType<Jar> {
+    from(rootProject.file("LICENSE.md"))
+}
+
+java {
+    toolchain.languageVersion = JavaLanguageVersion.of(versionOf("java"))
+    withSourcesJar()
+}
+
+publishing {
+    repositories {
+        val mavenUsername = providers.environmentVariable("MAVEN_USERNAME")
+        val mavenPassword = providers.environmentVariable("MAVEN_PASSWORD")
+        if (mavenUsername.isPresent && mavenPassword.isPresent) {
+            maven {
+                url = uri("https://maven.createmod.net")
+                credentials {
+                    username = mavenUsername.get()
+                    password = mavenPassword.get()
+                }
+            }
+        }
+
+        mavenLocal()
+    }
+
+    publications {
+        create<MavenPublication>("mavenJava") {
+            from(components.getByName("java"))
+            suppressAllPomMetadataWarnings()
+        }
+    }
+}
+
+// trick to sneak multiple entries into a single placeholder in a JSON file.
+// the file must be valid even with placeholders, so we can't just do something like this: [${placeholder}]
+// instead, the placeholder is expected to be in a string, like this: ["${placeholder}"]
+// this takes a string in the format 'a, b, c' and adds quotes, so the end result will be like this: a", "b", "c
+// when filled into the placeholder, you get a valid list: ["a", "b", "c"]
+fun String.formatForJson(): String = split(", ").joinToString("\", \"")

build-logic/src/main/kotlin/configure-common.gradle.kts

@@ -0,0 +1,9 @@
+import dev.engine_room.gradle.libraryOf
+
+plugins {
+    id("net.fabricmc.fabric-loom")
+}
+
+dependencies {
+    minecraft(libraryOf("minecraft"))
+}

build-logic/src/main/kotlin/configure-fabric.gradle.kts

@@ -0,0 +1,77 @@
+import dev.engine_room.gradle.Constants
+import dev.engine_room.gradle.getExt
+import dev.engine_room.gradle.libraryOf
+import net.fabricmc.loom.task.RenderDocRunTask
+import net.fabricmc.loom.task.RenderDocRunUITask
+import net.fabricmc.loom.task.RunGameTask
+import net.fabricmc.loom.util.Strings
+
+plugins {
+    id("net.fabricmc.fabric-loom")
+}
+
+val modId = getExt("mod_id")
+val modName = getExt("mod_name")
+
+
+val tracyCapturePath = providers.gradleProperty("loom.tracyCapturePath").map { File(it) }
+val renderDocCliPath = providers.gradleProperty("loom.renderDocCliPath").map { File(it) }
+val renderDocUiPath = providers.gradleProperty("loom.renderDocUiPath").map { File(it) }
+
+loom {
+    mods.maybeCreate(modId).apply {
+        sourceSet(sourceSets.getByName("main"))
+    }
+
+    runs {
+        named("client") {
+            jvmArguments.addAll(Constants.JVM_ARGUMENTS)
+            systemProperties.putAll(Constants.SYSTEM_PROPERTIES)
+            programArguments.addAll(Constants.PROGRAM_ARGUMENTS)
+        }
+
+        if (tracyCapturePath.isPresent) {
+            create("clientTracy") {
+                inherit(getByName("client"))
+            }
+        }
+
+        // We're a client mod, but we need to make sure we correctly render when playing on a server.
+        named("server")
+
+        configureEach {
+            generateRunConfig = true
+            preferGradleTask = true
+
+            displayName = "$modName Fabric ${Strings.capitalizeCamelCaseName(name)}"
+            ideConfigFolder = "Fabric"
+        }
+    }
+}
+
+tasks {
+    if (tracyCapturePath.isPresent) {
+        named<RunGameTask>("runClientTracy").configure {
+            tracy {
+                tracyCapture.set(tracyCapturePath.get())
+                output.set(workingDir.resolve("profile.tracy"))
+            }
+        }
+    }
+
+    if (renderDocCliPath.isPresent) {
+        withType<RenderDocRunTask>().configureEach {
+            renderDocExecutable.set(renderDocCliPath.get())
+        }
+    }
+
+    if (renderDocUiPath.isPresent) {
+        withType<RenderDocRunUITask>().configureEach {
+            renderDocExecutable.set(renderDocUiPath.get())
+        }
+    }
+}
+
+dependencies {
+    minecraft(libraryOf("minecraft"))
+}