Merge pull request #240 from IThundxr/feat/multi-loader-1.21

Port to 1.21.1

Author: Jozufozu

.github/workflows/build.yml

@@ -3,7 +3,7 @@ name: Build
 on: [ workflow_dispatch, pull_request, push ]
 
 env:
-  JAVA_VERSION: 17
+  JAVA_VERSION: 21
 
 jobs:
   build:
@@ -43,13 +43,15 @@ jobs:
           path: |
             common/build/libs/
             fabric/build/libs/
-            forge/build/libs/
+            neoforge/build/libs/
+            vanillinFabric/build/libs/
+            vanillinNeoForge/build/libs/
 
   test:
     strategy:
       fail-fast: false
       matrix:
-        loader: [ forge, fabric ]
+        loader: [ neoforge, fabric ]
     needs: build
     runs-on: ubuntu-latest
     steps:
@@ -63,15 +65,15 @@ jobs:
 
       - name: Setup Environment Variables
         run: |
-          echo "MOD_VERSION=$(grep '^mod_version =' gradle.properties | cut -d'=' -f2 | tr -d ' ')" >> "$GITHUB_ENV"
           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/flywheel-${{ matrix.loader }}-${{ env.MINECRAFT_VERSION }}-${{ env.MOD_VERSION }}.jar run/mods
-          cp ${{ matrix.loader }}/build/libs/flywheel-${{ matrix.loader }}-${{ env.MINECRAFT_VERSION }}-${{ env.MOD_VERSION }}-testmod.jar 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

README.md

@@ -39,8 +39,8 @@ repositories {
 }
 
 dependencies {
-    compileOnly fg.deobf("dev.engine_room.flywheel:flywheel-forge-api-${minecraft_version}:${flywheel_version}")
-    runtimeOnly fg.deobf("dev.engine_room.flywheel:flywheel-forge-${minecraft_version}:${flywheel_version}")
+    compileOnly fg.deobf("dev.engine_room.flywheel:flywheel-neoforge-api-${minecraft_version}:${flywheel_version}")
+    runtimeOnly fg.deobf("dev.engine_room.flywheel:flywheel-neoforge-${minecraft_version}:${flywheel_version}")
 }
 ```
 `${flywheel_version}` gets replaced by the version of Flywheel you want to use, eg. `1.0.0-beta`

buildSrc/build.gradle.kts

@@ -8,8 +8,8 @@ plugins {
 repositories {
     gradlePluginPortal()
     mavenCentral()
-    maven("https://maven.minecraftforge.net/") {
-        name = "MinecraftForge"
+    maven("https://maven.neoforged.net/releases/") {
+        name = "NeoForged"
     }
     maven("https://maven.architectury.dev/") {
         name = "Architectury"

buildSrc/src/main/kotlin/dev/engine_room/gradle/jarset/JarSetExtension.kt

@@ -13,10 +13,6 @@ open class JarSetExtension(private val project: Project) {
         return JarTaskSet.create(project, name, *sourceSetSet)
     }
 
-    fun outgoing(name: String, vararg sourceSetSet: SourceSet): JarTaskSet {
-        return JarTaskSet.create(project, name, *sourceSetSet).also { it.createOutgoingConfiguration() }
-    }
-
     val mainSet: JarTaskSet by lazy {
         val jarTask = project.tasks.named<Jar>("jar")
         val remapJarTask = project.tasks.named<RemapJarTask>("remapJar")

buildSrc/src/main/kotlin/dev/engine_room/gradle/jarset/JarTaskSet.kt

@@ -23,11 +23,11 @@ import org.gradle.language.jvm.tasks.ProcessResources
 class JarTaskSet(
     private val project: Project,
     private val name: String,
-    private val jar: TaskProvider<Jar>,
-    private val sources: TaskProvider<Jar>,
-    private val javadocJar: TaskProvider<Jar>,
-    private val remapJar: TaskProvider<RemapJarTask>,
-    private val remapSources: TaskProvider<RemapSourcesJarTask>
+    val jar: TaskProvider<Jar>,
+    val sources: TaskProvider<Jar>,
+    val javadocJar: TaskProvider<Jar>,
+    val remapJar: TaskProvider<RemapJarTask>,
+    val remapSources: TaskProvider<RemapSourcesJarTask>
 ) {
 
     fun publish(artifactId: String) {
@@ -41,10 +41,21 @@ class JarTaskSet(
         }
     }
 
-    /**
-     * Create a new configuration that can be consumed by other projects, and export the base jar.
-     */
-    fun createOutgoingConfiguration() {
+    fun outgoing(name: String) {
+        outgoingRemapJar("${name}Remap")
+        outgoingJar("${name}Dev")
+    }
+
+    fun outgoingRemapJar(name: String) {
+        val config = project.configurations.register(name) {
+            isCanBeConsumed = true
+            isCanBeResolved = false
+        }
+
+        project.artifacts.add(config.name, remapJar)
+    }
+
+    fun outgoingJar(name: String) {
         val config = project.configurations.register(name) {
             isCanBeConsumed = true
             isCanBeResolved = false

buildSrc/src/main/kotlin/dev/engine_room/gradle/platform/PlatformExtension.kt

@@ -1,30 +1,18 @@
 package dev.engine_room.gradle.platform
 
-import dev.engine_room.gradle.jarset.JarTaskSet
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
 import net.fabricmc.loom.task.RemapJarTask
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.SourceSetContainer
-import org.gradle.api.tasks.compile.JavaCompile
-import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
-import org.gradle.kotlin.dsl.*
-import org.gradle.language.jvm.tasks.ProcessResources
+import org.gradle.kotlin.dsl.assign
+import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.the
 import java.io.File
-import kotlin.properties.ReadWriteProperty
-import kotlin.reflect.KProperty
 
 open class PlatformExtension(val project: Project) {
-    var commonProject: Project by DependentProject(this.project)
-
-    var modArtifactId: String = "flywheel-${project.name}-${project.property("artifact_minecraft_version")}"
-
-    var apiArtifactId: String = "flywheel-${project.name}-api-${project.property("artifact_minecraft_version")}"
-
-    private val commonSourceSets: SourceSetContainer by lazy { commonProject.the<SourceSetContainer>() }
-
     fun setupLoomMod(vararg sourceSets: SourceSet) {
         project.the<LoomGradleExtensionAPI>().mods.maybeCreate("main").apply {
             sourceSets.forEach(::sourceSet)
@@ -56,52 +44,6 @@ open class PlatformExtension(val project: Project) {
         }
     }
 
-    fun compileWithCommonSourceSets(vararg sourceSets: SourceSet) {
-        project.tasks.apply {
-            withType<JavaCompile>().configureEach {
-                JarTaskSet.excludeDuplicatePackageInfos(this)
-            }
-
-            sourceSets.forEach {
-                val commonSourceSet = commonSourceSets.named(it.name).get()
-
-                named<JavaCompile>(it.compileJavaTaskName).configure {
-                    source(commonSourceSet.allJava)
-                }
-                named<ProcessResources>(it.processResourcesTaskName).configure {
-                    from(commonSourceSet.resources)
-                }
-            }
-        }
-    }
-
-    fun setupFatJar(vararg sourceSets: SourceSet) {
-        project.tasks.apply {
-            val extraSourceSets = sourceSets.filter { it.name != "main" }.toList()
-            val commonSources = sourceSets.map { commonSourceSets.named(it.name).get() }
-
-            named<Jar>("jar").configure {
-                extraSourceSets.forEach { from(it.output) }
-
-                JarTaskSet.excludeDuplicatePackageInfos(this)
-            }
-
-            named<Javadoc>("javadoc").configure {
-                commonSources.forEach { source(it.allJava) }
-                extraSourceSets.forEach { source(it.allJava) }
-
-                JarTaskSet.excludeDuplicatePackageInfos(this)
-            }
-
-            named<Jar>("sourcesJar").configure {
-                commonSources.forEach { from(it.allJava) }
-                extraSourceSets.forEach { from(it.allJava) }
-
-                JarTaskSet.excludeDuplicatePackageInfos(this)
-            }
-        }
-    }
-
     fun setupTestMod(sourceSet: SourceSet) {
         project.tasks.apply {
             val testModJar = register<Jar>("testModJar") {
@@ -124,20 +66,4 @@ open class PlatformExtension(val project: Project) {
             }
         }
     }
-
-    private class DependentProject(private val thisProject: Project) : ReadWriteProperty<Any?, Project> {
-        private var value: Project? = null
-
-        override fun getValue(thisRef: Any?, property: KProperty<*>): Project {
-            return value ?: throw IllegalStateException("Property ${property.name} should be initialized before get.")
-        }
-
-        override fun setValue(thisRef: Any?, property: KProperty<*>, value: Project) {
-            this.value = value
-            thisProject.evaluationDependsOn(value.path)
-        }
-
-        override fun toString(): String =
-            "NotNullProperty(${if (value != null) "value=$value" else "value not initialized yet"})"
-    }
 }