Port to 1.20.4 (NeoForge-only)

Author: 62832

.github/workflows/build.yml

@@ -19,6 +19,6 @@ jobs:
       - name: Set up Gradle
         uses: gradle/gradle-build-action@v2
       - name: Generate data
-        run: ./gradlew downloadAssets runData
+        run: ./gradlew runData
       - name: Build
         run: ./gradlew build

.github/workflows/release.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Set up Gradle
         uses: gradle/gradle-build-action@v2
       - name: Generate data
-        run: ./gradlew downloadAssets runData
+        run: ./gradlew runData
       - name: Build release files
         id: build
         env:

build.gradle.kts

@@ -1,260 +1,138 @@
-import net.fabricmc.loom.api.LoomGradleExtensionAPI
-import net.fabricmc.loom.task.RemapJarTask
-
 plugins {
-    `kotlin-dsl`
-    java
-    `maven-publish`
-    alias(libs.plugins.loom) apply false
-    alias(libs.plugins.architectury)
-    alias(libs.plugins.shadow)
+    alias(libs.plugins.neogradle)
     alias(libs.plugins.spotless)
 }
 
-val modId: String by project
-val modVersion = (System.getenv("MEGA_VERSION") ?: "v0.0.0").substring(1)
-val minecraftVersion = libs.versions.minecraft.get()
+val modId = "megacells"
 
-val platforms by extra {
-    property("enabledPlatforms").toString().split(',')
-}
+base.archivesName = modId
+version = System.getenv("MEGA_VERSION") ?: "0.0.0"
+group = "gripe.90"
 
-tasks {
-    register("releaseInfo") {
-        doLast {
-            val output = System.getenv("GITHUB_OUTPUT")
+java.toolchain.languageVersion = JavaLanguageVersion.of(17)
 
-            if (!output.isNullOrEmpty()) {
-                val outputFile = File(output)
-                outputFile.appendText("MOD_VERSION=$modVersion\n")
-                outputFile.appendText("MINECRAFT_VERSION=$minecraftVersion\n")
-            }
+repositories {
+    mavenLocal()
+    mavenCentral()
+
+    maven {
+        name = "ModMaven (K4U-NL)"
+        url = uri("https://modmaven.dev/")
+        content {
+            includeGroup("appeng")
         }
     }
 
-    withType<Jar> {
-        enabled = false
+    maven {
+        name = "Modrinth Maven"
+        url = uri("https://api.modrinth.com/maven")
+        content {
+            includeGroup("maven.modrinth")
+        }
     }
 }
 
-subprojects {
-    apply(plugin = "java")
-    apply(plugin = rootProject.libs.plugins.architectury.get().pluginId)
-    apply(plugin = rootProject.libs.plugins.loom.get().pluginId)
-    apply(plugin = rootProject.libs.plugins.spotless.get().pluginId)
-
-    base.archivesName.set("$modId-${project.name}")
-    version = "$modVersion-$minecraftVersion"
-    group = property("mavenGroup").toString()
-    
-    val javaVersion: String by project
-
-    java {
-        sourceCompatibility = JavaVersion.valueOf("VERSION_$javaVersion")
-        targetCompatibility = JavaVersion.valueOf("VERSION_$javaVersion")
+dependencies {
+    implementation(libs.neoforge)
+    implementation(libs.ae2)
 
-        withSourcesJar()
-    }
+    implementation(libs.ae2wtlib)
+    runtimeOnly(libs.curios)
+}
 
-    architectury {
-        minecraft = minecraftVersion
-        injectInjectables = false
+sourceSets {
+    main {
+        resources.srcDir(file("src/generated/resources"))
     }
-
-    configure<LoomGradleExtensionAPI> {
-        silentMojangMappingsLicense()
-
-        @Suppress("UnstableApiUsage")
-        mixin.defaultRefmapName.set("$modId.refmap.json")
+    
+    create("data") {
+        val main = main.get()
+        compileClasspath += main.compileClasspath + main.output
+        runtimeClasspath += main.runtimeClasspath + main.output
     }
+}
 
-    repositories {
-        mavenLocal()
-        mavenCentral()
-
-        maven {
-            name = "ModMaven (K4U-NL)"
-            url = uri("https://modmaven.dev/")
-            content {
-                includeGroup("appeng")
-                includeGroup("mezz.jei")
-            }
-        }
-
-        maven {
-            name = "BlameJared"
-            url = uri("https://maven.blamejared.com")
-            content {
-                includeGroup("vazkii.botania")
-                includeGroup("vazkii.patchouli")
-            }
-        }
-
-        maven {
-            name = "Modrinth Maven"
-            url = uri("https://api.modrinth.com/maven")
-            content {
-                includeGroup("maven.modrinth")
-            }
-        }
+runs {
+    configureEach {
+        workingDirectory(file("run"))
+        systemProperty("forge.logging.console.level", "info")
+        
+        modSource(sourceSets.main.get())
     }
-
-    dependencies {
-        "minecraft"(rootProject.libs.minecraft)
-        "mappings"(project.extensions.getByName<LoomGradleExtensionAPI>("loom").officialMojangMappings())
+    
+    create("client")
+    create("server")
+    
+    create("data") {
+        programArguments.addAll(
+            "--mod", modId,
+            "--all",
+            "--output", file("src/generated/resources/").absolutePath,
+            "--existing", file("src/main/resources/").absolutePath)
+        
+        modSource(sourceSets.getByName("data"))
     }
+}
 
-    sourceSets {
-        create("data") {
-            val main = sourceSets.main.get()
-            compileClasspath += main.compileClasspath + main.output
-            runtimeClasspath += main.runtimeClasspath + main.output
+tasks {
+    jar {
+        from(rootProject.file("LICENSE")) {
+            rename { "${it}_$modId" }
         }
     }
 
-    tasks {
-        jar {
-            from(rootProject.file("LICENSE")) {
-                rename { "${it}_$modId"}
-            }
-        }
-
-        withType<JavaCompile> {
-            options.encoding = "UTF-8"
-            options.release.set(javaVersion.toInt())
-        }
+    withType<JavaCompile> {
+        options.encoding = "UTF-8"
     }
-
-    spotless {
-        kotlinGradle {
-            target("*.kts")
-            diktat()
-        }
-
-        java {
-            target("src/**/java/**/*.java")
-            endWithNewline()
-            indentWithSpaces(4)
-            removeUnusedImports()
-            palantirJavaFormat()
-            importOrderFile(rootProject.file("codeformat/mega.importorder"))
-
-            // courtesy of diffplug/spotless#240
-            // https://github.com/diffplug/spotless/issues/240#issuecomment-385206606
-            custom("noWildcardImports") {
-                if (it.contains("*;\n")) {
-                    throw Error("No wildcard imports allowed")
-                }
-
-                it
-            }
-
-            bumpThisNumberIfACustomStepChanges(1)
-        }
-
-        json {
-            target("src/**/resources/**/*.json")
-            targetExclude("src/generated/resources/**")
-            biome()
-            indentWithSpaces(2)
-            endWithNewline()
+    
+    processResources {
+        exclude("**/.cache")
+        
+        val props = mapOf(
+            "version" to version,
+            "ae2Version" to libs.versions.ae2.get(),
+            "ae2VersionEnd" to libs.versions.ae2.get().substringBefore('.').toInt() + 1,
+        )
+        
+        inputs.properties(props)
+        filesMatching("META-INF/mods.toml") {
+            expand(props)
         }
     }
 }
 
-for (platform in platforms) {
-    project(":$platform") {
-        apply(plugin = rootProject.libs.plugins.shadow.get().pluginId)
-
-        architectury {
-            platformSetupLoomIde()
-            loader(platform)
-        }
-
-        fun capitalise(str: String): String {
-            return str.replaceFirstChar {
-                if (it.isLowerCase()) {
-                    it.titlecase()
-                } else {
-                    it.toString()
-                }
-            }
-        }
-
-        val common: Configuration by configurations.creating
-        val shadowCommon: Configuration by configurations.creating
-
-        @Suppress("UnstableApiUsage")
-        configurations {
-            compileClasspath { extendsFrom(common) }
-            runtimeClasspath { extendsFrom(common) }
-            getByName("development${capitalise(platform)}") { extendsFrom(common) }
-        }
-
-        dependencies {
-            common(project(path = ":common", configuration = "namedElements")) {
-                isTransitive = false
-            }
+spotless {
+    kotlinGradle {
+        target("*.kts")
+        diktat()
+    }
 
-            shadowCommon(project(path = ":common", configuration = "transformProduction${capitalise(platform)}")) {
-                isTransitive = false
-            }
-        }
+    java {
+        target("/src/**/java/**/*.java")
+        endWithNewline()
+        indentWithSpaces(4)
+        removeUnusedImports()
+        palantirJavaFormat()
+        importOrderFile(file("mega.importorder"))
 
-        sourceSets {
-            main {
-                resources {
-                    srcDir(file("src/generated/resources"))
-                    exclude("**/.cache")
-                }
+        // courtesy of diffplug/spotless#240
+        // https://github.com/diffplug/spotless/issues/240#issuecomment-385206606
+        custom("noWildcardImports") {
+            if (it.contains("*;\n")) {
+                throw Error("No wildcard imports allowed")
             }
 
-            getByName("data") {
-                val commonData = project(":common").sourceSets.getByName("data")
-                compileClasspath += commonData.output
-                runtimeClasspath += commonData.output
-            }
+            it
         }
 
-        tasks {
-            processResources {
-                val commonProps by extra { mapOf(
-                        "version"           to project.version,
-                        "minecraftVersion"  to minecraftVersion,
-                        "ae2Version"        to rootProject.libs.versions.ae2.get(),
-                        "ae2wtVersion"      to rootProject.libs.versions.ae2wtlib.get(),
-                        "appbotVersion"     to rootProject.libs.versions.appbot.get())
-                }
-
-                inputs.properties(commonProps)
-            }
-
-            shadowJar {
-                exclude("architectury.common.json")
-                configurations = listOf(shadowCommon)
-                archiveClassifier.set("dev-shadow")
-            }
-
-            withType<RemapJarTask> {
-                inputFile.set(shadowJar.get().archiveFile)
-                dependsOn(shadowJar)
-                archiveClassifier.set(null as String?)
-            }
-
-            jar {
-                archiveClassifier.set("dev")
-            }
-
-            getByName<Jar>("sourcesJar") {
-                val commonSources = project(":common").tasks.getByName<Jar>("sourcesJar")
-                dependsOn(commonSources)
-                from(commonSources.archiveFile.map { zipTree(it) })
-            }
-        }
+        bumpThisNumberIfACustomStepChanges(1)
+    }
 
-        val javaComponent = components["java"] as AdhocComponentWithVariants
-        javaComponent.withVariantsFromConfiguration(configurations["shadowRuntimeElements"]) {
-            skip()
-        }
+    json {
+        target("src/**/resources/**/*.json")
+        targetExclude("src/generated/resources/**")
+        biome()
+        indentWithSpaces(2)
+        endWithNewline()
     }
 }