Merge branch 'mc-1.20.x' into mc-1.21.x

Oh, I'm sure I missed something here. This was a nasty merge, has the
docs have changed so much in each version.

buildSrc/src/main/kotlin/cc-tweaked.forge.gradle.kts

@@ -11,20 +11,18 @@ import cc.tweaked.gradle.MinecraftConfigurations
 
 plugins {
     id("cc-tweaked.java-convention")
-    id("net.neoforged.gradle.userdev")
+    id("net.neoforged.moddev")
 }
 
 plugins.apply(CCTweakedPlugin::class.java)
 
 val mcVersion: String by extra
 
-minecraft {
-    modIdentifier("computercraft")
-}
+neoForge {
+    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
+    version = libs.findVersion("neoForge").get().toString()
 
-subsystems {
     parchment {
-        val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
         minecraftVersion = libs.findVersion("parchmentMc").get().toString()
         mappingsVersion = libs.findVersion("parchment").get().toString()
     }

buildSrc/src/main/kotlin/cc-tweaked.java-convention.gradle.kts

@@ -99,6 +99,7 @@ sourceSets.all {
             check("OperatorPrecedence", CheckSeverity.OFF) // For now.
             check("NonOverridingEquals", CheckSeverity.OFF) // Peripheral.equals makes this hard to avoid
             check("FutureReturnValueIgnored", CheckSeverity.OFF) // Too many false positives with Netty
+            check("InvalidInlineTag", CheckSeverity.OFF) // Triggered by @snippet. Can be removed on Java 21.
 
             check("NullAway", CheckSeverity.ERROR)
             option(

buildSrc/src/main/kotlin/cc-tweaked.mod.gradle.kts

@@ -2,15 +2,16 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-import cc.tweaked.gradle.clientClasses
-import cc.tweaked.gradle.commonClasses
-
 /**
  * Sets up the configurations for writing game tests.
  *
  * See notes in [cc.tweaked.gradle.MinecraftConfigurations] for the general design behind these cursed ideas.
  */
 
+import cc.tweaked.gradle.MinecraftConfigurations
+import cc.tweaked.gradle.clientClasses
+import cc.tweaked.gradle.commonClasses
+
 plugins {
     id("cc-tweaked.kotlin-convention")
     id("cc-tweaked.java-convention")
@@ -19,33 +20,16 @@ plugins {
 val main = sourceSets["main"]
 val client = sourceSets["client"]
 
-// datagen and testMod inherit from the main and client classpath, just so we have access to Minecraft classes.
-val datagen by sourceSets.creating {
-    compileClasspath += main.compileClasspath + client.compileClasspath
-    runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
-}
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.DATAGEN)
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.EXAMPLES)
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.TEST_MOD)
 
-val testMod by sourceSets.creating {
-    compileClasspath += main.compileClasspath + client.compileClasspath
-    runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
-}
+// Set up generated resources
+sourceSets.main { resources.srcDir("src/generated/resources") }
+sourceSets.named("examples") { resources.srcDir("src/examples/generatedResources") }
 
-val extraConfigurations = listOf(datagen, testMod)
-
-configurations {
-    for (config in extraConfigurations) {
-        named(config.compileClasspathConfigurationName) { shouldResolveConsistentlyWith(compileClasspath.get()) }
-        named(config.runtimeClasspathConfigurationName) { shouldResolveConsistentlyWith(runtimeClasspath.get()) }
-    }
-}
-
-// Like the main test configurations, we're safe to depend on source set outputs.
-dependencies {
-    for (config in extraConfigurations) {
-        add(config.implementationConfigurationName, main.output)
-        add(config.implementationConfigurationName, client.output)
-    }
-}
+// Make sure our examples compile.
+tasks.check { dependsOn(tasks.named("compileExamplesJava")) }
 
 // Similar to java-test-fixtures, but tries to avoid putting the obfuscated jar on the classpath.
 

buildSrc/src/main/kotlin/cc/tweaked/gradle/CCTweakedExtension.kt

@@ -113,7 +113,7 @@ abstract class CCTweakedExtension(
         // Pull in sources from the other project.
         extendSourceSet(otherProject, main)
         extendSourceSet(otherProject, client)
-        for (sourceSet in listOf("datagen", "testMod", "testFixtures")) {
+        for (sourceSet in listOf(MinecraftConfigurations.DATAGEN, MinecraftConfigurations.EXAMPLES, MinecraftConfigurations.TEST_MOD, "testFixtures")) {
             otherJava.sourceSets.findByName(sourceSet)?.let { extendSourceSet(otherProject, it) }
         }
 

buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftConfigurations.kt

@@ -24,7 +24,6 @@ class MinecraftConfigurations private constructor(private val project: Project)
     private val java = project.extensions.getByType(JavaPluginExtension::class.java)
     private val sourceSets = java.sourceSets
     private val configurations = project.configurations
-    private val objects = project.objects
 
     private val main = sourceSets[SourceSet.MAIN_SOURCE_SET_NAME]
     private val test = sourceSets[SourceSet.TEST_SOURCE_SET_NAME]
@@ -37,13 +36,7 @@ class MinecraftConfigurations private constructor(private val project: Project)
         val client = sourceSets.maybeCreate("client")
 
         // Ensure the client classpaths behave the same as the main ones.
-        configurations.named(client.compileClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
-        }
-
-        configurations.named(client.runtimeClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
-        }
+        consistentWithMain(client)
 
         // Set up an API configuration for clients (to ensure it's consistent with the main source set).
         val clientApi = configurations.maybeCreate(client.apiConfigurationName).apply {
@@ -85,6 +78,16 @@ class MinecraftConfigurations private constructor(private val project: Project)
         setupBasic()
     }
 
+    private fun consistentWithMain(sourceSet: SourceSet) {
+        configurations.named(sourceSet.compileClasspathConfigurationName) {
+            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
+        }
+
+        configurations.named(sourceSet.runtimeClasspathConfigurationName) {
+            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
+        }
+    }
+
     private fun setupBasic() {
         val client = sourceSets["client"]
 
@@ -102,7 +105,24 @@ class MinecraftConfigurations private constructor(private val project: Project)
         project.tasks.named("check") { dependsOn(checkDependencyConsistency) }
     }
 
+    /**
+     * Create a new configuration that pulls in the main and client classes from the mod.
+     */
+    private fun createDerivedConfiguration(name: String) {
+        val client = sourceSets["client"]
+        val sourceSet = sourceSets.create(name)
+        sourceSet.compileClasspath += main.compileClasspath + client.compileClasspath
+        sourceSet.runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
+        consistentWithMain(sourceSet)
+        project.dependencies.add(sourceSet.implementationConfigurationName, main.output)
+        project.dependencies.add(sourceSet.implementationConfigurationName, client.output)
+    }
+
     companion object {
+        const val DATAGEN = "datagen"
+        const val EXAMPLES = "examples"
+        const val TEST_MOD = "testMod"
+
         fun setupBasic(project: Project) {
             MinecraftConfigurations(project).setupBasic()
         }
@@ -110,6 +130,10 @@ class MinecraftConfigurations private constructor(private val project: Project)
         fun setup(project: Project) {
             MinecraftConfigurations(project).setup()
         }
+
+        fun createDerivedConfiguration(project: Project, name: String) {
+            MinecraftConfigurations(project).createDerivedConfiguration(name)
+        }
     }
 }
 

buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftExec.kt

@@ -4,6 +4,7 @@
 
 package cc.tweaked.gradle
 
+import net.neoforged.moddevgradle.internal.RunGameTask
 import org.gradle.api.GradleException
 import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.invocation.Gradle
@@ -65,6 +66,22 @@ abstract class ClientJavaExec : JavaExec() {
         setTestProperties()
     }
 
+    fun copyFromForge(path: String) = copyFromForge(project.tasks.getByName(path, RunGameTask::class))
+
+    /**
+     * Set this task to run a given [RunGameTask].
+     */
+    fun copyFromForge(task: RunGameTask) {
+        copyFrom(task)
+
+        // Eagerly evaluate the behaviour of RunGameTask.exec
+        environment.putAll(task.environmentProperty.get())
+        classpath(task.classpathProvider)
+        workingDir = task.gameDirectory.get().asFile
+
+        setTestProperties() // setRunConfig may clobber some properties, ensure everything is set.
+    }
+
     /**
      * Copy configuration from a task with the given name.
      */