Fix JEI integration for MC 1.21

- Use the client side registry access (possible now that we've moved
   JEI to the client).

 - Generate unique ids for JEI recipes.

.github/workflows/main-ci.yml

@@ -9,16 +9,16 @@ jobs:
 
     steps:
     - name: 📥 Clone repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: 📥 Set up Java
-      uses: actions/setup-java@v3
+      uses: actions/setup-java@v4
       with:
-        java-version: 17
+        java-version: 21
         distribution: 'temurin'
 
     - name: 📥 Setup Gradle
-      uses: gradle/gradle-build-action@v2
+      uses: gradle/actions/setup-gradle@v3
       with:
         cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
 
@@ -58,13 +58,13 @@ jobs:
         find projects/forge/build/libs projects/fabric/build/libs -type f -regex '.*[0-9.]+\(-SNAPSHOT\)?\.jar$' -exec bash -c 'cp {} "jars/$(basename {} .jar)-$(git rev-parse HEAD).jar"' \;
 
     - name: 📤 Upload Jar
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: CC-Tweaked
         path: ./jars
 
     - name: 📤 Upload coverage
-      uses: codecov/codecov-action@v3
+      uses: codecov/codecov-action@v4
 
   build-core:
     strategy:
@@ -81,24 +81,28 @@ jobs:
     runs-on: ${{ matrix.uses }}
 
     steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
+    - name: 📥 Clone repository
+      uses: actions/checkout@v4
 
-    - name: Set up Java
-      uses: actions/setup-java@v3
+    - name: 📥 Set up Java
+      uses: actions/setup-java@v4
       with:
-        java-version: 17
+        java-version: 21
         distribution: 'temurin'
 
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2
+    - name: 📥 Setup Gradle
+      uses: gradle/actions/setup-gradle@v3
       with:
         cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
 
-    - name: Run tests
+    - name: ⚒️ Build
+      run: |
+        ./gradlew --configure-on-demand :core:assemble
+
+    - name: 🧪 Run tests
       run: |
         ./gradlew --configure-on-demand :core:test
 
-    - name: Parse test reports
+    - name: 🧪 Parse test reports
       run: python3 ./tools/parse-reports.py
       if: ${{ failure() }}

.github/workflows/make-doc.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-DEST="${GITHUB_REF#refs/*/}"
-echo "Uploading docs to https://tweaked.cc/$DEST"
-
-# Setup ssh key
-mkdir -p "$HOME/.ssh/"
-echo "$SSH_KEY" > "$HOME/.ssh/key"
-chmod 600 "$HOME/.ssh/key"
-
-# And upload
-rsync -avc -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no -p $SSH_PORT" \
-      "$GITHUB_WORKSPACE/projects/web/build/site/" \
-      "$SSH_USER@$SSH_HOST:/$DEST"
-rsync -avc -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no -p $SSH_PORT" \
-      "$GITHUB_WORKSPACE/projects/common-api/build/docs/javadoc/" \
-      "$SSH_USER@$SSH_HOST:/$DEST/javadoc"

.github/workflows/make-doc.yml

@@ -3,8 +3,7 @@ name: Build documentation
 on:
   push:
     branches:
-    - mc-1.19.x
-    - mc-1.20.x
+    - mc-*
 
 jobs:
   make_doc:
@@ -12,30 +11,25 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
+    - name: 📥 Clone repository
+      uses: actions/checkout@v4
 
-    - name: Set up Java
-      uses: actions/setup-java@v1
+    - name: 📥 Set up Java
+      uses: actions/setup-java@v4
       with:
-        java-version: 17
+        java-version: 21
         distribution: 'temurin'
 
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2
+    - name: 📥 Setup Gradle
+      uses: gradle/actions/setup-gradle@v3
       with:
         cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
 
-    - name: Build with Gradle
-      run: ./gradlew compileJava --no-daemon || ./gradlew compileJava --no-daemon
+    - name: ⚒️ Generate documentation
+      run: ./gradlew docWebsite --no-daemon
 
-    - name: Generate documentation
-      run: ./gradlew docWebsite :common-api:javadoc  --no-daemon
-
-    - name: Upload documentation
-      run: .github/workflows/make-doc.sh 2> /dev/null
-      env:
-        SSH_KEY:  ${{ secrets.SSH_KEY  }}
-        SSH_USER: ${{ secrets.SSH_USER }}
-        SSH_HOST: ${{ secrets.SSH_HOST }}
-        SSH_PORT: ${{ secrets.SSH_PORT }}
+    - name: 📤 Upload Jar
+      uses: actions/upload-artifact@v4
+      with:
+        name: Documentation
+        path: ./projects/web/build/site/

.gitignore

@@ -7,7 +7,9 @@
 /logs
 /build
 /projects/*/logs
+/projects/fabric/fabricloader.log
 /projects/*/build
+/projects/*/src/test/generated_tests/
 /buildSrc/build
 /out
 /buildSrc/out

.gitpod.yml

@@ -1,26 +0,0 @@
-# SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: MPL-2.0
-
-image:
-  file: config/gitpod/Dockerfile
-
-ports:
-  - port: 25565
-    onOpen: notify
-
-vscode:
-  extensions:
-    - eamodio.gitlens
-    - github.vscode-pull-request-github
-    - ms-azuretools.vscode-docker
-    - redhat.java
-    - richardwillis.vscode-gradle
-    - vscjava.vscode-java-debug
-    - vscode.github
-
-tasks:
-  - name: Setup pre-commit hool
-    init: pre-commit install --allow-missing-config
-  - name: Install npm packages
-    init: npm ci

.reuse/dep5

@@ -6,10 +6,9 @@ Upstream-Contact: Jonathan Coates <git@squiddev.cc>
 Files:
   projects/common/src/main/resources/assets/computercraft/sounds.json
   projects/common/src/main/resources/assets/computercraft/sounds/empty.ogg
-  projects/common/src/testMod/resources/data/cctest/computercraft/turtle_upgrades/*
+  projects/common/src/testMod/resources/data/cctest/computercraft/turtle_upgrade/*
   projects/common/src/testMod/resources/data/cctest/structures/*
-  projects/fabric/src/generated/*
-  projects/forge/src/generated/*
+  projects/*/src/generated/*
   projects/web/src/htmlTransform/export/index.json
   projects/web/src/htmlTransform/export/items/minecraft/*
 Comment: Generated/data files are CC0.
@@ -37,6 +36,7 @@ Files:
   projects/fabric/src/testMod/resources/computercraft-gametest.fabric.mixins.json
   projects/fabric/src/testMod/resources/fabric.mod.json
   projects/forge/src/client/resources/computercraft-client.forge.mixins.json
+  projects/forge/src/main/resources/computercraft.forge.mixins.json
   projects/web/src/frontend/mount/.settings
   projects/web/src/frontend/mount/example.nfp
   projects/web/src/frontend/mount/example.nft

CONTRIBUTING.md

@@ -29,9 +29,9 @@ automatically with GitHub, so please don't submit PRs adding/changing translatio
 In order to develop CC: Tweaked, you'll need to download the source code and then run it.
 
  - Make sure you've got the following software installed:
-   - Java Development Kit (JDK) installed. This can be downloaded from [Adoptium].
+   - Java Development Kit (JDK). This can be downloaded from [Adoptium].
    - [Git](https://git-scm.com/).
-   - If you want to work on documentation, [NodeJS][node].
+   - [NodeJS][node].
 
  - Download CC: Tweaked's source code:
    ```

README.md

@@ -42,7 +42,6 @@ repositories {
     url "https://squiddev.cc/maven/"
     content {
       includeGroup("cc.tweaked")
-      includeModule("org.squiddev", "Cobalt")
     }
   }
 }
@@ -52,9 +51,8 @@ dependencies {
   compileOnly("cc.tweaked:cc-tweaked-$mcVersion-common-api:$cctVersion")
 
   // Forge Gradle
-  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-core-api:$cctVersion")
-  compileOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion"))
-  runtimeOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion"))
+  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion")
+  runtimeOnly("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion")
 
   // Fabric Loom
   modCompileOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric-api:$cctVersion")
@@ -76,8 +74,8 @@ minecraft {
 ```
 
 You should also be careful to only use classes within the `dan200.computercraft.api` package. Non-API classes are
-subject to change at any point. If you depend on functionality outside the API, file an issue, and we can look into
-exposing more features.
+subject to change at any point. If you depend on functionality outside the API (or need to mixin to CC:T), please file
+an issue to let me know!
 
 We bundle the API sources with the jar, so documentation should be easily viewable within your editor. Alternatively,
 the generated documentation [can be browsed online](https://tweaked.cc/javadoc/).

build.gradle.kts

@@ -5,14 +5,15 @@
 import cc.tweaked.gradle.JUnitExt
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
 import net.fabricmc.loom.util.gradle.SourceSetHelper
-import org.jetbrains.gradle.ext.compiler
-import org.jetbrains.gradle.ext.runConfigurations
-import org.jetbrains.gradle.ext.settings
+import org.jetbrains.gradle.ext.*
+import org.jetbrains.gradle.ext.Application
 
 plugins {
     publishing
     alias(libs.plugins.taskTree)
     alias(libs.plugins.githubRelease)
+    alias(libs.plugins.gradleVersions)
+    alias(libs.plugins.versionCatalogUpdate)
     id("org.jetbrains.gradle.plugin.idea-ext")
     id("cc-tweaked")
 }
@@ -84,6 +85,19 @@ idea.project.settings.runConfigurations {
         moduleName = "${idea.project.name}.forge.test"
         packageName = ""
     }
+
+    register<Application>("Standalone") {
+        moduleName = "${idea.project.name}.standalone.main"
+        mainClass = "cc.tweaked.standalone.Main"
+        programParameters = "--resources=projects/core/src/main/resources --term=80x30 --allow-local-domains"
+    }
+}
+
+// Build with the IntelliJ, rather than through Gradle. This may require setting the "Compiler Output" option in
+// "Project Structure".
+idea.project.settings.delegateActions {
+    delegateBuildRunToGradle = false
+    testRunner = ActionDelegationConfig.TestRunner.PLATFORM
 }
 
 idea.project.settings.compiler.javac {
@@ -102,3 +116,9 @@ idea.project.settings.compiler.javac {
         }
         .toMap()
 }
+
+versionCatalogUpdate {
+    sortByKey.set(false)
+    pin { versions.addAll("fastutil", "guava", "netty", "slf4j") }
+    keep { keepUnusedLibraries.set(true) }
+}

buildSrc/build.gradle.kts

@@ -5,6 +5,8 @@
 plugins {
     `java-gradle-plugin`
     `kotlin-dsl`
+    alias(libs.plugins.gradleVersions)
+    alias(libs.plugins.versionCatalogUpdate)
 }
 
 // Duplicated in settings.gradle.kts
@@ -12,25 +14,14 @@ repositories {
     mavenCentral()
     gradlePluginPortal()
 
-    maven("https://maven.minecraftforge.net") {
-        name = "Forge"
+    maven("https://maven.neoforged.net/releases") {
+        name = "NeoForge"
         content {
             includeGroup("net.minecraftforge")
-            includeGroup("net.minecraftforge.gradle")
-        }
-    }
-
-    maven("https://maven.parchmentmc.org") {
-        name = "Librarian"
-        content {
-            includeGroupByRegex("^org\\.parchmentmc.*")
-        }
-    }
-
-    maven("https://repo.spongepowered.org/repository/maven-public/") {
-        name = "Sponge"
-        content {
-            includeGroup("org.spongepowered")
+            includeGroup("net.neoforged")
+            includeGroup("net.neoforged.gradle")
+            includeModule("codechicken", "DiffPatch")
+            includeModule("net.covers1624", "Quack")
         }
     }
 
@@ -40,6 +31,13 @@ repositories {
             includeGroup("net.fabricmc")
         }
     }
+
+    maven("https://squiddev.cc/maven") {
+        name = "SquidDev"
+        content {
+            includeGroup("cc.tweaked.vanilla-extract")
+        }
+    }
 }
 
 dependencies {
@@ -49,12 +47,10 @@ dependencies {
 
     implementation(libs.curseForgeGradle)
     implementation(libs.fabric.loom)
-    implementation(libs.forgeGradle)
     implementation(libs.ideaExt)
-    implementation(libs.librarian)
     implementation(libs.minotaur)
-    implementation(libs.vanillaGradle)
-    implementation(libs.vineflower)
+    implementation(libs.neoGradle.userdev)
+    implementation(libs.vanillaExtract)
 }
 
 gradlePlugin {
@@ -75,3 +71,9 @@ gradlePlugin {
         }
     }
 }
+
+versionCatalogUpdate {
+    sortByKey.set(false)
+    keep { keepUnusedLibraries.set(true) }
+    catalogFile.set(file("../gradle/libs.versions.toml"))
+}

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

@@ -12,7 +12,6 @@ import cc.tweaked.gradle.MinecraftConfigurations
 plugins {
     `java-library`
     id("fabric-loom")
-    id("io.github.juuxel.loom-vineflower")
     id("cc-tweaked.java-convention")
 }
 

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

@@ -10,10 +10,8 @@ import cc.tweaked.gradle.IdeaRunConfigurations
 import cc.tweaked.gradle.MinecraftConfigurations
 
 plugins {
-    id("net.minecraftforge.gradle")
-    // We must apply java-convention after Forge, as we need the fg extension to be present.
     id("cc-tweaked.java-convention")
-    id("org.parchmentmc.librarian.forgegradle")
+    id("net.neoforged.gradle.userdev")
 }
 
 plugins.apply(CCTweakedPlugin::class.java)
@@ -21,10 +19,15 @@ plugins.apply(CCTweakedPlugin::class.java)
 val mcVersion: String by extra
 
 minecraft {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    mappings("parchment", "${libs.findVersion("parchmentMc").get()}-${libs.findVersion("parchment").get()}-$mcVersion")
+    modIdentifier("computercraft")
+}
 
-    accessTransformer(project(":forge").file("src/main/resources/META-INF/accesstransformer.cfg"))
+subsystems {
+    parchment {
+        val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
+        minecraftVersion = libs.findVersion("parchmentMc").get().toString()
+        mappingsVersion = libs.findVersion("parchment").get().toString()
+    }
 }
 
 MinecraftConfigurations.setup(project)
@@ -32,13 +35,3 @@ MinecraftConfigurations.setup(project)
 extensions.configure(CCTweakedExtension::class.java) {
     linters(minecraft = true, loader = "forge")
 }
-
-dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    "minecraft"("net.minecraftforge:forge:$mcVersion-${libs.findVersion("forge").get()}")
-}
-
-tasks.configureEach {
-    // genIntellijRuns isn't registered until much later, so we need this silly hijinks.
-    if (name == "genIntellijRuns") doLast { IdeaRunConfigurations(project).patch() }
-}

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

@@ -40,21 +40,10 @@ repositories {
 
     val mainMaven = maven("https://squiddev.cc/maven") {
         name = "SquidDev"
-        content {
-            // Until https://github.com/SpongePowered/Mixin/pull/593 is merged
-            includeModule("org.spongepowered", "mixin")
-        }
     }
 
     exclusiveContent {
         forRepositories(mainMaven)
-
-        // Include the ForgeGradle repository if present. This requires that ForgeGradle is already present, which we
-        // enforce in our Forge overlay.
-        val fg =
-            project.extensions.findByType(net.minecraftforge.gradle.userdev.DependencyManagementExtension::class.java)
-        if (fg != null) forRepositories(fg.repository)
-
         filter {
             includeGroup("cc.tweaked")
             // Things we mirror
@@ -67,7 +56,6 @@ repositories {
             includeGroup("mezz.jei")
             includeGroup("org.teavm")
             includeModule("com.terraformersmc", "modmenu")
-            includeModule("me.lucko", "fabric-permissions-api")
         }
     }
 }
@@ -76,6 +64,12 @@ dependencies {
     val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
     checkstyle(libs.findLibrary("checkstyle").get())
 
+    constraints {
+        checkstyle("org.codehaus.plexus:plexus-container-default:2.1.1") {
+            because("2.1.0 depends on deprecated Google collections module")
+        }
+    }
+
     errorprone(libs.findLibrary("errorProne-core").get())
     errorprone(libs.findLibrary("nullAway").get())
 }
@@ -83,8 +77,16 @@ dependencies {
 // Configure default JavaCompile tasks with our arguments.
 sourceSets.all {
     tasks.named(compileJavaTaskName, JavaCompile::class.java) {
-        // Processing just gives us "No processor claimed any of these annotations", so skip that!
-        options.compilerArgs.addAll(listOf("-Xlint", "-Xlint:-processing"))
+
+        options.compilerArgs.addAll(
+            listOf(
+                "-Xlint",
+                // Processing just gives us "No processor claimed any of these annotations", so skip that!
+                "-Xlint:-processing",
+                // We violate this pattern too often for it to be a helpful warning. Something to improve one day!
+                "-Xlint:-this-escape",
+            ),
+        )
 
         options.errorprone {
             check("InvalidBlockTag", CheckSeverity.OFF) // Broken by @cc.xyz
@@ -92,9 +94,8 @@ sourceSets.all {
             check("InlineMeSuggester", CheckSeverity.OFF) // Minecraft uses @Deprecated liberally
             // Too many false positives right now. Maybe we need an indirection for it later on.
             check("ReferenceEquality", CheckSeverity.OFF)
-            check("UnusedVariable", CheckSeverity.OFF) // Too many false positives with records.
+            check("EnumOrdinal", CheckSeverity.OFF) // For now. We could replace most of these with EnumMap.
             check("OperatorPrecedence", CheckSeverity.OFF) // For now.
-            check("AlreadyChecked", CheckSeverity.OFF) // Seems to be broken?
             check("NonOverridingEquals", CheckSeverity.OFF) // Peripheral.equals makes this hard to avoid
             check("FutureReturnValueIgnored", CheckSeverity.OFF) // Too many false positives with Netty
 
@@ -107,6 +108,8 @@ sourceSets.all {
             option("NullAway:CastToNonNullMethod", "dan200.computercraft.core.util.Nullability.assertNonNull")
             option("NullAway:CheckOptionalEmptiness")
             option("NullAway:AcknowledgeRestrictiveAnnotations")
+
+            excludedPaths = ".*/jmh_generated/.*"
         }
     }
 }
@@ -151,7 +154,7 @@ tasks.javadoc {
     options {
         val stdOptions = this as StandardJavadocDocletOptions
         stdOptions.addBooleanOption("Xdoclint:all,-missing", true)
-        stdOptions.links("https://docs.oracle.com/en/java/javase/17/docs/api/")
+        stdOptions.links("https://docs.oracle.com/en/java/javase/21/docs/api/")
     }
 }
 
@@ -201,6 +204,7 @@ spotless {
     val ktlintConfig = mapOf(
         "ktlint_standard_no-wildcard-imports" to "disabled",
         "ktlint_standard_class-naming" to "disabled",
+        "ktlint_standard_function-naming" to "disabled",
         "ij_kotlin_allow_trailing_comma" to "true",
         "ij_kotlin_allow_trailing_comma_on_call_site" to "true",
     )

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

@@ -32,7 +32,7 @@ val publishCurseForge by tasks.registering(TaskPublishCurseForge::class) {
     apiToken = findProperty("curseForgeApiKey") ?: ""
     enabled = apiToken != ""
 
-    val mainFile = upload("282001", modPublishing.output.get().archiveFile)
+    val mainFile = upload("282001", modPublishing.output)
     mainFile.changelog =
         "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion)."
     mainFile.changelogType = "markdown"

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

@@ -10,25 +10,31 @@ import cc.tweaked.gradle.MinecraftConfigurations
 
 plugins {
     id("cc-tweaked.java-convention")
-    id("org.spongepowered.gradle.vanilla")
+    id("cc.tweaked.vanilla-extract")
 }
 
 plugins.apply(CCTweakedPlugin::class.java)
 
 val mcVersion: String by extra
 
+val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
+
 minecraft {
     version(mcVersion)
+
+    mappings {
+        parchment(libs.findVersion("parchmentMc").get().toString(), libs.findVersion("parchment").get().toString())
+    }
+
+    unpick(libs.findLibrary("yarn").get())
 }
 
 dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-
     // Depend on error prone annotations to silence a lot of compile warnings.
-    compileOnlyApi(libs.findLibrary("errorProne.annotations").get())
+    compileOnly(libs.findLibrary("errorProne.annotations").get())
 }
 
-MinecraftConfigurations.setup(project)
+MinecraftConfigurations.setupBasic(project)
 
 extensions.configure(CCTweakedExtension::class.java) {
     linters(minecraft = true, loader = null)

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

@@ -10,9 +10,11 @@ import org.gradle.api.GradleException
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.artifacts.Dependency
 import org.gradle.api.attributes.TestSuiteType
 import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Provider
 import org.gradle.api.provider.SetProperty
 import org.gradle.api.reporting.ReportingExtension
@@ -33,7 +35,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import java.io.File
 import java.io.IOException
 import java.net.URI
-import java.net.URL
 import java.util.regex.Pattern
 
 abstract class CCTweakedExtension(
@@ -73,11 +74,17 @@ abstract class CCTweakedExtension(
      */
     val sourceDirectories: SetProperty<SourceSetReference> = project.objects.setProperty(SourceSetReference::class.java)
 
+    /**
+     * Dependencies excluded from published artifacts.
+     */
+    private val excludedDeps: ListProperty<Dependency> = project.objects.listProperty(Dependency::class.java)
+
     /** All source sets referenced by this project. */
     val sourceSets = sourceDirectories.map { x -> x.map { it.sourceSet } }
 
     init {
         sourceDirectories.finalizeValueOnRead()
+        excludedDeps.finalizeValueOnRead()
         project.afterEvaluate { sourceDirectories.disallowChanges() }
     }
 
@@ -218,12 +225,12 @@ abstract class CCTweakedExtension(
      * where possible.
      */
     fun downloadFile(label: String, url: String): File {
-        val url = URL(url)
-        val path = File(url.path)
+        val uri = URI(url)
+        val path = File(uri.path)
 
         project.repositories.ivy {
             name = label
-            setUrl(URI(url.protocol, url.userInfo, url.host, url.port, path.parent, null, null))
+            setUrl(URI(uri.scheme, uri.userInfo, uri.host, uri.port, path.parent, null, null))
             patternLayout {
                 artifact("[artifact].[ext]")
             }
@@ -246,6 +253,20 @@ abstract class CCTweakedExtension(
         ).resolve().single()
     }
 
+    /**
+     * Exclude a dependency from being published in Maven.
+     */
+    fun exclude(dep: Dependency) {
+        excludedDeps.add(dep)
+    }
+
+    /**
+     * Configure a [MavenDependencySpec].
+     */
+    fun configureExcludes(spec: MavenDependencySpec) {
+        for (dep in excludedDeps.get()) spec.exclude(dep)
+    }
+
     companion object {
         private val COMMIT_COUNTS = Pattern.compile("""^\s*[0-9]+\s+(.*)$""")
         private val IGNORED_USERS = setOf(

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

@@ -42,6 +42,6 @@ class CCTweakedPlugin : Plugin<Project> {
     }
 
     companion object {
-        val JAVA_VERSION = JavaLanguageVersion.of(17)
+        val JAVA_VERSION = JavaLanguageVersion.of(21)
     }
 }

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

@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package cc.tweaked.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier
+import org.gradle.api.artifacts.component.ModuleComponentSelector
+import org.gradle.api.artifacts.component.ProjectComponentIdentifier
+import org.gradle.api.artifacts.result.DependencyResult
+import org.gradle.api.artifacts.result.ResolvedDependencyResult
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.MapProperty
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.TaskAction
+import org.gradle.language.base.plugins.LifecycleBasePlugin
+
+abstract class DependencyCheck : DefaultTask() {
+    @get:Input
+    abstract val configuration: ListProperty<Configuration>
+
+    /**
+     * A mapping of module coordinates (`group:module`) to versions, overriding the requested version.
+     */
+    @get:Input
+    abstract val overrides: MapProperty<String, String>
+
+    init {
+        description = "Check :core's dependencies are consistent with Minecraft's."
+        group = LifecycleBasePlugin.VERIFICATION_GROUP
+
+        configuration.finalizeValueOnRead()
+        overrides.finalizeValueOnRead()
+    }
+
+    /**
+     * Override a module with a different version.
+     */
+    fun override(module: Provider<MinimalExternalModuleDependency>, version: String) {
+        overrides.putAll(project.provider { mutableMapOf(module.get().module.toString() to version) })
+    }
+
+    @TaskAction
+    fun run() {
+        var ok = true
+        for (configuration in configuration.get()) {
+            configuration.incoming.resolutionResult.allDependencies {
+                if (!check(this@allDependencies)) ok = false
+            }
+        }
+
+        if (!ok) {
+            throw GradleException("Mismatched versions in Minecraft dependencies. gradle/libs.versions.toml may need updating.")
+        }
+    }
+
+    private fun check(dependency: DependencyResult): Boolean {
+        if (dependency !is ResolvedDependencyResult) {
+            logger.warn("Found unexpected dependency result {}", dependency)
+            return false
+        }
+
+        // Skip dependencies on non-modules.
+        val requested = dependency.requested
+        if (requested !is ModuleComponentSelector) return true
+
+        // If this dependency is specified within some project (so is non-transitive), or is pulled in via Minecraft,
+        // then check for consistency.
+        // It would be nice to be smarter about transitive dependencies, but avoiding false positives is hard.
+        val from = dependency.from.id
+        if (
+            from is ProjectComponentIdentifier ||
+            from is ModuleComponentIdentifier && (from.group == "net.minecraft" || from.group == "io.netty")
+        ) {
+            // If the version is different between the requested and selected version, report an error.
+            val selected = dependency.selected.moduleVersion!!.version
+            val requestedVersion = overrides.get()["${requested.group}:${requested.module}"] ?: requested.version
+            if (requestedVersion != selected) {
+                logger.error("Requested dependency {} (via {}) but got version {}", requested, from, selected)
+                return false
+            }
+
+            return true
+        }
+        return true
+    }
+}

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

@@ -6,7 +6,6 @@ package cc.tweaked.gradle
 
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.file.FileSystemLocation
-import org.gradle.api.file.FileSystemLocationProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.JavaExec
@@ -129,3 +128,30 @@ fun <T> Property<T>.setProvider(provider: Provider<out T>) = set(provider)
 
 /** Short-cut method to get the absolute path of a [FileSystemLocation] provider. */
 fun Provider<out FileSystemLocation>.getAbsolutePath(): String = get().asFile.absolutePath
+
+/**
+ * Get the version immediately after the provided version.
+ *
+ * For example, given "1.2.3", this will return "1.2.4".
+ */
+fun getNextVersion(version: String): String {
+    // Split a version like x.y.z-SNAPSHOT into x.y.z and -SNAPSHOT
+    val dashIndex = version.indexOf('-')
+    val mainVersion = if (dashIndex < 0) version else version.substring(0, dashIndex)
+
+    // Find the last component in x.y.z and increment it.
+    val lastIndex = mainVersion.lastIndexOf('.')
+    if (lastIndex < 0) throw IllegalArgumentException("Cannot parse version format \"$version\"")
+    val lastVersion = try {
+        version.substring(lastIndex + 1).toInt()
+    } catch (e: NumberFormatException) {
+        throw IllegalArgumentException("Cannot parse version format \"$version\"", e)
+    }
+
+    // Then append all components together.
+    val out = StringBuilder()
+    out.append(version, 0, lastIndex + 1)
+    out.append(lastVersion + 1)
+    if (dashIndex >= 0) out.append(version, dashIndex, version.length)
+    return out.toString()
+}

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

@@ -4,23 +4,59 @@
 
 package cc.tweaked.gradle
 
-import net.minecraftforge.gradle.common.util.RunConfig
-import net.minecraftforge.gradle.common.util.runs.setRunConfigInternal
+import net.neoforged.gradle.common.runs.run.RunImpl
+import net.neoforged.gradle.common.runs.tasks.RunExec
+import net.neoforged.gradle.dsl.common.extensions.RunnableSourceSet
+import net.neoforged.gradle.dsl.common.runs.run.Run
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.SourceSet
 import org.gradle.jvm.toolchain.JavaToolchainService
+import org.gradle.kotlin.dsl.assign
+import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.findByType
 import java.nio.file.Files
 
 /**
  * Set [JavaExec] task to run a given [RunConfig].
+ *
+ * See also [RunExec].
  */
-fun JavaExec.setRunConfig(config: RunConfig) {
-    dependsOn("prepareRuns")
-    setRunConfigInternal(project, this, config)
-    doFirst("Create working directory") { Files.createDirectories(workingDir.toPath()) }
+fun JavaExec.setRunConfig(config: Run) {
+    mainClass.set(config.mainClass)
+    workingDir = config.workingDirectory.get().asFile
+    argumentProviders.add { config.programArguments.get() }
+    jvmArgumentProviders.add { config.jvmArguments.get() }
+
+    environment(config.environmentVariables.get())
+    systemProperties(config.systemProperties.get())
+
+    config.modSources.all().get().values().forEach { classpath(it.runtimeClasspath) }
+    classpath(config.classpath)
+    classpath(config.dependencies.get().runtimeConfiguration)
+
+    (config as RunImpl).taskDependencies.forEach { dependsOn(it) }
 
     javaLauncher.set(
         project.extensions.getByType(JavaToolchainService::class.java)
             .launcherFor(project.extensions.getByType(JavaPluginExtension::class.java).toolchain),
     )
+
+    doFirst("Create working directory") { Files.createDirectories(workingDir.toPath()) }
+}
+
+/**
+ * Add a new [Run.modSource] with a specific mod id.
+ */
+fun Run.modSourceAs(sourceSet: SourceSet, mod: String) {
+    // NeoGradle requires a RunnableSourceSet to be present, so we inject it into other project's source sets.
+    val runnable = sourceSet.extensions.findByType<RunnableSourceSet>() ?: run {
+        val extension = sourceSet.extensions.create<RunnableSourceSet>(RunnableSourceSet.NAME, project)
+        extension.modIdentifier = mod
+        extension.modIdentifier.finalizeValueOnRead()
+        extension
+    }
+    if (runnable.modIdentifier.get() != mod) throw IllegalArgumentException("Multiple mod identifiers")
+
+    modSource(sourceSet)
 }

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

@@ -6,6 +6,8 @@ package cc.tweaked.gradle
 
 import org.gradle.api.artifacts.Dependency
 import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.artifacts.ProjectDependency
+import org.gradle.api.plugins.BasePluginExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.specs.Spec
 
@@ -26,8 +28,13 @@ class MavenDependencySpec {
 
     fun exclude(dep: Dependency) {
         exclude {
+            // We have to cheat a little for project dependencies, as the project name doesn't match the artifact group.
+            val name = when (dep) {
+                is ProjectDependency -> dep.dependencyProject.extensions.getByType(BasePluginExtension::class.java).archivesName.get()
+                else -> dep.name
+            }
             (dep.group.isNullOrEmpty() || dep.group == it.groupId) &&
-                (dep.name.isNullOrEmpty() || dep.name == it.artifactId) &&
+                (name.isNullOrEmpty() || name == it.artifactId) &&
                 (dep.version.isNullOrEmpty() || dep.version == it.version)
         }
     }

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

@@ -0,0 +1,120 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package cc.tweaked.gradle
+
+import cc.tweaked.vanillaextract.core.util.MoreFiles
+import org.gradle.api.Action
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.file.*
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.tasks.*
+import javax.inject.Inject
+
+/**
+ * Merge common files across multiple directories into one destination directory.
+ *
+ * This is intended for merging the generated resources from the Forge and Fabric projects. Files common between the two
+ * are written to the global [output] directory, while distinct files are written to the per-source
+ * [MergeTrees.Source.output] directory.
+ */
+abstract class MergeTrees : DefaultTask() {
+    /**
+     * A source directory to read from.
+     */
+    interface Source {
+        /**
+         * The folder contianing all input files.
+         */
+        @get:InputFiles
+        @get:PathSensitive(PathSensitivity.RELATIVE)
+        val input: ConfigurableFileTree
+
+        fun input(configure: Action<ConfigurableFileTree>) {
+            configure.execute(input)
+        }
+
+        /**
+         * The folder to write files unique to this folder to.
+         */
+        @get:OutputDirectory
+        val output: DirectoryProperty
+    }
+
+    /**
+     * The list of sources.
+     */
+    @get:Nested
+    abstract val sources: ListProperty<Source>
+
+    /**
+     * Add and configure a new source.
+     */
+    fun source(configure: Action<Source>) {
+        val instance = objectFactory.newInstance(Source::class.java)
+        configure.execute(instance)
+        instance.output.disallowChanges()
+        sources.add(instance)
+    }
+
+    /**
+     * The directory to write common files to.
+     */
+    @get:OutputDirectory
+    abstract val output: DirectoryProperty
+
+    @get:Inject
+    protected abstract val objectFactory: ObjectFactory
+
+    @get:Inject
+    protected abstract val fsOperations: FileSystemOperations
+
+    @TaskAction
+    fun run() {
+        val sources = this.sources.get()
+        if (sources.isEmpty()) throw GradleException("Cannot have an empty list of sources")
+
+        val files = mutableMapOf<String, SharedFile>()
+        for (source in sources) {
+            source.input.visit(
+                object : FileVisitor {
+                    override fun visitDir(dirDetails: FileVisitDetails) = Unit
+                    override fun visitFile(fileDetails: FileVisitDetails) {
+                        val path = fileDetails.file.toRelativeString(source.input.dir)
+                        val hash = MoreFiles.computeSha1(fileDetails.file.toPath())
+
+                        val existing = files[path]
+                        if (existing == null) {
+                            files[path] = SharedFile(hash, 1)
+                        } else if (existing.hash == hash) {
+                            existing.found++
+                        }
+                    }
+                },
+            )
+        }
+
+        val sharedFiles = files.entries.asSequence().filter { (_, v) -> v.found == sources.size }.map { (k, _) -> k }.toList()
+
+        // Copy shared files to the common directory
+        fsOperations.sync {
+            from(sources[0].input)
+            into(output)
+            include(sharedFiles)
+        }
+
+        // And all other files to their per-source directory
+        for (source in sources) {
+            fsOperations.sync {
+                from(source.input)
+                into(source.output)
+                exclude(sharedFiles)
+            }
+        }
+    }
+
+    class SharedFile(val hash: String, var found: Int)
+}

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

@@ -4,23 +4,17 @@
 
 package cc.tweaked.gradle
 
+import cc.tweaked.vanillaextract.configurations.Capabilities
+import cc.tweaked.vanillaextract.configurations.MinecraftSetup
 import org.gradle.api.Project
-import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ModuleDependency
 import org.gradle.api.artifacts.dsl.DependencyHandler
-import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Category
-import org.gradle.api.attributes.LibraryElements
-import org.gradle.api.attributes.Usage
-import org.gradle.api.attributes.java.TargetJvmVersion
-import org.gradle.api.capabilities.Capability
 import org.gradle.api.plugins.BasePlugin
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.kotlin.dsl.get
-import org.gradle.kotlin.dsl.named
 
 /**
  * This sets up a separate client-only source set, and extends that and the main/common source set with additional
@@ -59,31 +53,13 @@ class MinecraftConfigurations private constructor(private val project: Project)
         }
         configurations.named(client.implementationConfigurationName) { extendsFrom(clientApi) }
 
-        /*
-          Now add outgoing variants for the main and common source sets that we can consume downstream. This is possibly
-          the worst way to do things, but unfortunately the alternatives don't actually work very well:
-
-           - Just using source set outputs: This means dependencies don't propagate, which means when :fabric depends
-             on :fabric-api, we don't inherit the fake :common-api in IDEA.
-
-           - Having separate common/main jars: Nice in principle, but unfortunately Forge needs a separate deobf jar
-             task (as the original jar is obfuscated), and IDEA is not able to map its output back to a source set.
-
-          This works for now, but is incredibly brittle. It's part of the reason we can't use testFixtures inside our
-          MC projects, as that adds a project(self) -> test dependency, which would pull in the jar instead.
-
-          Note we register a fake client jar here. It's not actually needed, but is there to make sure IDEA has
-          a way to tell that client classes are needed at runtime.
-
-          I'm so sorry, deeply aware how cursed this is.
-        */
-        setupOutgoing(main, "CommonOnly")
         project.tasks.register(client.jarTaskName, Jar::class.java) {
             description = "An empty jar standing in for the client classes."
             group = BasePlugin.BUILD_GROUP
             archiveClassifier.set("client")
         }
-        setupOutgoing(client)
+
+        MinecraftSetup(project).setupOutgoingConfigurations()
 
         // Reset the client classpath (Loom configures it slightly differently to this) and add a main -> client
         // dependency. Here we /can/ use source set outputs as we add transitive deps by patching the classpath. Nasty,
@@ -106,88 +82,39 @@ class MinecraftConfigurations private constructor(private val project: Project)
         project.tasks.named("jar", Jar::class.java) { from(client.output) }
         project.tasks.named("sourcesJar", Jar::class.java) { from(client.allSource) }
 
+        setupBasic()
+    }
+
+    private fun setupBasic() {
+        val client = sourceSets["client"]
+
         project.extensions.configure(CCTweakedExtension::class.java) {
             sourceDirectories.add(SourceSetReference.internal(client))
         }
-    }
 
-    private fun setupOutgoing(sourceSet: SourceSet, suffix: String = "") {
-        setupOutgoing("${sourceSet.apiElementsConfigurationName}$suffix", sourceSet, objects.named(Usage.JAVA_API)) {
-            description = "API elements for ${sourceSet.name}"
-            extendsFrom(configurations[sourceSet.apiConfigurationName])
-        }
-
-        setupOutgoing("${sourceSet.runtimeElementsConfigurationName}$suffix", sourceSet, objects.named(Usage.JAVA_RUNTIME)) {
-            description = "Runtime elements for ${sourceSet.name}"
-            extendsFrom(configurations[sourceSet.implementationConfigurationName], configurations[sourceSet.runtimeOnlyConfigurationName])
-        }
-    }
-
-    /**
-     * Set up an outgoing configuration for a specific source set. We set an additional "main" or "client" capability
-     * (depending on the source set name) which allows downstream projects to consume them separately (see
-     * [DependencyHandler.commonClasses] and [DependencyHandler.clientClasses]).
-     */
-    private fun setupOutgoing(name: String, sourceSet: SourceSet, usage: Usage, configure: Configuration.() -> Unit) {
-        configurations.register(name) {
-            isVisible = false
-            isCanBeConsumed = true
-            isCanBeResolved = false
-
-            configure(this)
-
-            attributes {
-                attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
-                attribute(Usage.USAGE_ATTRIBUTE, usage)
-                attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
-                attributeProvider(
-                    TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE,
-                    java.toolchain.languageVersion.map { it.asInt() },
-                )
-                attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
+        // Register a task to check there are no conflicts with the core project.
+        val checkDependencyConsistency =
+            project.tasks.register("checkDependencyConsistency", DependencyCheck::class.java) {
+                // We need to check both the main and client classpath *configurations*, as the actual configuration
+                configuration.add(configurations.named(main.runtimeClasspathConfigurationName))
+                configuration.add(configurations.named(client.runtimeClasspathConfigurationName))
             }
-
-            outgoing {
-                capability(BasicOutgoingCapability(project, sourceSet.name))
-
-                // We have two outgoing variants here: the original jar and the classes.
-                artifact(project.tasks.named(sourceSet.jarTaskName))
-
-                variants.create("classes") {
-                    attributes.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.CLASSES))
-                    sourceSet.output.classesDirs.forEach { artifact(it) { builtBy(sourceSet.output) } }
-                }
-            }
-        }
+        project.tasks.named("check") { dependsOn(checkDependencyConsistency) }
     }
 
     companion object {
+        fun setupBasic(project: Project) {
+            MinecraftConfigurations(project).setupBasic()
+        }
+
         fun setup(project: Project) {
             MinecraftConfigurations(project).setup()
         }
     }
 }
 
-private class BasicIncomingCapability(private val module: ModuleDependency, private val name: String) : Capability {
-    override fun getGroup(): String = module.group!!
-    override fun getName(): String = "${module.name}-$name"
-    override fun getVersion(): String? = null
-}
+fun DependencyHandler.clientClasses(notation: Any): ModuleDependency =
+    Capabilities.clientClasses(create(notation) as ModuleDependency)
 
-private class BasicOutgoingCapability(private val project: Project, private val name: String) : Capability {
-    override fun getGroup(): String = project.group.toString()
-    override fun getName(): String = "${project.name}-$name"
-    override fun getVersion(): String = project.version.toString()
-}
-
-fun DependencyHandler.clientClasses(notation: Any): ModuleDependency {
-    val dep = create(notation) as ModuleDependency
-    dep.capabilities { requireCapability(BasicIncomingCapability(dep, "client")) }
-    return dep
-}
-
-fun DependencyHandler.commonClasses(notation: Any): ModuleDependency {
-    val dep = create(notation) as ModuleDependency
-    dep.capabilities { requireCapability(BasicIncomingCapability(dep, "main")) }
-    return dep
-}
+fun DependencyHandler.commonClasses(notation: Any): ModuleDependency =
+    Capabilities.commonClasses(create(notation) as ModuleDependency)

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

@@ -4,7 +4,6 @@
 
 package cc.tweaked.gradle
 
-import net.minecraftforge.gradle.common.util.RunConfig
 import org.gradle.api.GradleException
 import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.invocation.Gradle
@@ -65,14 +64,6 @@ abstract class ClientJavaExec : JavaExec() {
         setTestProperties()
     }
 
-    /**
-     * Set this task to run a given [RunConfig].
-     */
-    fun setRunConfig(config: RunConfig) {
-        (this as JavaExec).setRunConfig(config)
-        setTestProperties() // setRunConfig may clobber some properties, ensure everything is set.
-    }
-
     /**
      * Copy configuration from a task with the given name.
      */

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

@@ -46,7 +46,7 @@ abstract class NpmInstall : DefaultTask() {
     @TaskAction
     fun install() {
         project.exec {
-            commandLine("npm", "ci")
+            commandLine(ProcessHelpers.getExecutable("npm"), "ci")
             workingDir = projectRoot.get().asFile
         }
     }
@@ -59,6 +59,6 @@ abstract class NpmInstall : DefaultTask() {
 abstract class NpxExecToDir : ExecToDir() {
     init {
         dependsOn(NpmInstall.TASK_NAME)
-        executable = "npx"
+        executable = ProcessHelpers.getExecutable("npx")
     }
 }

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

@@ -9,6 +9,7 @@ import org.gradle.api.GradleException
 import java.io.BufferedReader
 import java.io.File
 import java.io.InputStreamReader
+import java.nio.charset.StandardCharsets
 
 internal object ProcessHelpers {
     fun startProcess(vararg command: String): Process {
@@ -34,7 +35,7 @@ internal object ProcessHelpers {
         val process = startProcess(*command)
         process.outputStream.close()
 
-        val out = BufferedReader(InputStreamReader(process.inputStream)).use { reader ->
+        val out = BufferedReader(InputStreamReader(process.inputStream, StandardCharsets.UTF_8)).use { reader ->
             reader.lines().filter { it.isNotEmpty() }.toList()
         }
         ProcessGroovyMethods.closeStreams(process)
@@ -46,6 +47,28 @@ internal object ProcessHelpers {
         val path = System.getenv("PATH") ?: return false
         return path.splitToSequence(File.pathSeparator).any { File(it, name).exists() }
     }
+
+    /**
+     * Search for an executable on the `PATH` if required.
+     *
+     * [Process]/[ProcessBuilder] does not handle all executable file extensions on Windows (such as `.com). When on
+     * Windows, this function searches `PATH` and `PATHEXT` for an executable matching [name].
+     */
+    fun getExecutable(name: String): String {
+        if (!System.getProperty("os.name").lowercase().contains("windows")) return name
+
+        val path = (System.getenv("PATH") ?: return name).split(File.pathSeparator)
+        val pathExt = (System.getenv("PATHEXT") ?: return name).split(File.pathSeparator)
+
+        for (pathEntry in path) {
+            for (ext in pathExt) {
+                val resolved = File(pathEntry, name + ext)
+                if (resolved.exists()) return resolved.getAbsolutePath()
+            }
+        }
+
+        return name
+    }
 }
 
 internal fun Process.waitForOrThrow(message: String) {

buildSrc/src/main/kotlin/net/minecraftforge/gradle/common/util/runs/RunConfigSetup.kt

@@ -1,51 +0,0 @@
-// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package net.minecraftforge.gradle.common.util.runs
-
-import net.minecraftforge.gradle.common.util.RunConfig
-import org.gradle.api.Project
-import org.gradle.process.CommandLineArgumentProvider
-import org.gradle.process.JavaExecSpec
-import java.io.File
-import java.util.function.Supplier
-import java.util.stream.Collectors
-import java.util.stream.Stream
-
-/**
- * Set up a [JavaExecSpec] to execute a [RunConfig].
- *
- * [MinecraftRunTask] sets up all its properties when the task is executed, rather than when configured. As such, it's
- * not possible to use [cc.tweaked.gradle.copyToFull] like we do for Fabric. Instead, we set up the task manually.
- *
- * Unfortunately most of the functionality we need is package-private, and so we have to put our code into the package.
- */
-internal fun setRunConfigInternal(project: Project, spec: JavaExecSpec, config: RunConfig) {
-    spec.workingDir = File(config.workingDirectory)
-
-    spec.mainClass.set(config.main)
-    for (source in config.allSources) spec.classpath(source.runtimeClasspath)
-
-    val originalTask = project.tasks.named(config.taskName, MinecraftRunTask::class.java)
-
-    // Add argument and JVM argument via providers, to be as lazy as possible with fetching artifacts.
-    val lazyTokens = RunConfigGenerator.configureTokensLazy(
-        project, config, RunConfigGenerator.mapModClassesToGradle(project, config),
-        originalTask.get().minecraftArtifacts,
-        originalTask.get().runtimeClasspathArtifacts,
-    )
-    spec.argumentProviders.add(
-        CommandLineArgumentProvider {
-            RunConfigGenerator.getArgsStream(config, lazyTokens, false).toList()
-        },
-    )
-    spec.jvmArgumentProviders.add(
-        CommandLineArgumentProvider {
-            (if (config.isClient) config.jvmArgs + originalTask.get().additionalClientArgs.get() else config.jvmArgs).map { config.replace(lazyTokens, it) } +
-                config.properties.map { (k, v) -> "-D${k}=${config.replace(lazyTokens, v)}" }
-        },
-    )
-
-    for ((key, value) in config.environment) spec.environment(key, config.replace(lazyTokens, value))
-}

config/checkstyle/checkstyle.xml

@@ -13,8 +13,12 @@ SPDX-License-Identifier: MPL-2.0
     <property name="tabWidth" value="4"/>
     <property name="charset" value="UTF-8" />
 
+    <module name="BeforeExecutionExclusionFileFilter">
+        <property name="fileNamePattern" value="module\-info\.java$"/>
+    </module>
+
     <module name="SuppressionFilter">
-	<property name="file" value="${config_loc}/suppressions.xml" />
+        <property name="file" value="${config_loc}/suppressions.xml" />
     </module>
 
     <module name="BeforeExecutionExclusionFileFilter">

config/checkstyle/suppressions.xml

@@ -21,5 +21,8 @@ SPDX-License-Identifier: MPL-2.0
     <suppress checks="PackageName" files=".*[\\/]T[A-Za-z]+.java" />
 
     <!-- Allow underscores in our test classes. -->
-    <suppress checks="MethodName" files=".*Contract.java" />
+    <suppress checks="MethodName" files=".*(Contract|Test).java" />
+
+    <!-- Allow underscores in Mixin classes -->
+    <suppress checks="TypeName" files=".*[\\/]mixin[\\/].*.java" />
 </suppressions>

config/gitpod/Dockerfile

@@ -1,12 +0,0 @@
-# SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: MPL-2.0
-
-FROM gitpod/workspace-base
-
-USER gitpod
-
-RUN sudo apt-get -q update \
- && sudo apt-get install -yq openjdk-16-jdk python3-pip npm \
- && sudo pip3 install pre-commit \
- && sudo update-java-alternatives --set java-1.16.0-openjdk-amd64

doc/guides/gps_setup.md

@@ -19,7 +19,7 @@ In order to give the best results, a GPS constellation needs at least four compu
 constellation is redundant, but it does not cause problems.
 
 ## Building a GPS constellation
-<img alt="An example GPS constellation." src="/images/gps-constellation-example.png" class="big-image" />
+<img alt="An example GPS constellation." src="../images/gps-constellation-example.png" class="big-image" />
 
 We are going to build our GPS constellation as shown in the image above. You will need 4 computers and either 4 wireless
 modems or 4 ender modems. Try not to mix ender and wireless modems together as you might get some odd behavior when your

doc/guides/speaker_audio.md

@@ -131,7 +131,7 @@ different.
 First, we require the dfpwm module and call [`cc.audio.dfpwm.make_decoder`] to construct a new decoder. This decoder
 accepts blocks of DFPWM data and converts it to a list of 8-bit amplitudes, which we can then play with our speaker.
 
-As mentioned above, [`speaker.playAudio`] accepts at most 128×1024 samples in one go. DFPMW uses a single bit for each
+As mentioned above, [`speaker.playAudio`] accepts at most 128×1024 samples in one go. DFPWM uses a single bit for each
 sample, which means we want to process our audio in chunks of 16×1024 bytes (16KiB). In order to do this, we use
 [`io.lines`], which provides a nice way to loop over chunks of a file. You can of course just use [`fs.open`] and
 [`fs.ReadHandle.read`] if you prefer.

doc/index.md

@@ -4,7 +4,14 @@ SPDX-FileCopyrightText: 2020 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->
 
-# ![CC: Tweaked](logo.png)
+<h1>
+    <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="logo-darkmode.png">
+        <source media="(prefers-color-scheme: light)" srcset="logo.png">
+        <img alt="CC: Tweaked" src="logo.png">
+    </picture>
+</h1>
+
 CC: Tweaked is a mod for Minecraft which adds programmable computers, turtles and more to the game. A fork of the
 much-beloved [ComputerCraft], it continues its legacy with improved performance and stability, along with a wealth of
 new features.
@@ -38,7 +45,7 @@ little daunting getting started. Thankfully, there's several fantastic tutorials
 
  - [Direwolf20's ComputerCraft tutorials](https://www.youtube.com/watch?v=wrUHUhfCY5A "ComputerCraft Tutorial Episode 1 - HELP! and Hello World")
  - [Sethbling's ComputerCraft series](https://www.youtube.com/watch?v=DSsx4VSe-Uk "Programming Tutorial with Minecraft Turtles -- Ep. 1: Intro to Turtles and If-Then-Else_End")
- - [Lyqyd's Computer Basics 1](http://www.computercraft.info/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
+ - [Lyqyd's Computer Basics 1](https://ccf.squiddev.cc/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
 
 Once you're a little more familiar with the mod, the sidebar and links below provide more detailed documentation on the
 various APIs and peripherals provided by the mod.

doc/mod-page.md

@@ -45,7 +45,7 @@ little daunting getting started. Thankfully, there's several fantastic tutorials
 
  - [Direwolf20's ComputerCraft tutorials](https://www.youtube.com/watch?v=wrUHUhfCY5A "ComputerCraft Tutorial Episode 1 - HELP! and Hello World")
  - [Sethbling's ComputerCraft series](https://www.youtube.com/watch?v=DSsx4VSe-Uk "Programming Tutorial with Minecraft Turtles -- Ep. 1: Intro to Turtles and If-Then-Else_End")
- - [Lyqyd's Computer Basics 1](http://www.computercraft.info/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
+ - [Lyqyd's Computer Basics 1](https://ccf.squiddev.cc/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
 
 Once you're a little more familiar with the mod, the [wiki](https://tweaked.cc/) provides more detailed documentation on the
 various APIs and peripherals provided by the mod.

doc/reference/breaking_changes.md

@@ -21,7 +21,7 @@ of the mod should run fine on later versions.
 However, some changes to the underlying game, or CC: Tweaked's own internals may break some programs. This page serves
 as documentation for breaking changes and "gotchas" one should look out for between versions.
 
-## CC: Tweaked 1.109.0 {#cct-1.109}
+## CC: Tweaked 1.109.0 to 1.109.3 {#cct-1.109}
 
  - Update to Lua 5.2:
    - Support for Lua 5.0's pseudo-argument `arg` has been removed. You should always use `...` for varargs.
@@ -31,6 +31,7 @@ as documentation for breaking changes and "gotchas" one should look out for betw
    - `load`/`loadstring` defaults to using the global environment (`_G`) rather than the current coroutine's
      environment.
    - Support for dumping functions (`string.dump`) and loading binary chunks has been removed.
+   - `math.random` now uses Lua 5.4's random number generator.
 
  - File handles, HTTP requests and websockets now always use the original bytes rather than encoding/decoding to UTF-8.
 
@@ -75,6 +76,6 @@ as documentation for breaking changes and "gotchas" one should look out for betw
  - Programs containing `/` are looked up in the current directory and are no longer looked up on the path. For instance,
    you can no longer type `turtle/excavate` to run `/rom/programs/turtle/excavate.lua`.
 
-[flattening]: https://minecraft.wiki.com/w/Java_Edition_1.13/Flattening
-[legal_data_pack]: https://minecraft.gamepedia.com/Tutorials/Creating_a_data_pack#Legal_characters
+[flattening]: https://minecraft.wiki/w/Java_Edition_1.13/Flattening
+[legal_data_pack]: https://minecraft.wiki/w/Tutorials/Creating_a_data_pack#Legal_characters
 [datapack-example]: https://github.com/cc-tweaked/datapack-example "An example datapack for CC: Tweaked"

doc/reference/command.md

@@ -0,0 +1,140 @@
+---
+module: [kind=reference] computercraft_command
+---
+
+<!--
+SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
+
+SPDX-License-Identifier: MPL-2.0
+-->
+
+# The `/computercraft` command
+CC: Tweaked provides a `/computercraft` command for server owners to manage running computers on a server.
+
+## Permissions {#permissions}
+As the `/computercraft` command is mostly intended for debugging and administrative purposes, its sub-commands typically
+require you to have op (or similar).
+
+ - All players have access to the [`queue`] sub-command.
+ - On a multi-player server, all other commands require op.
+ - On a single-player world, the player can run the [`dump`], [`turn-on`]/[`shutdown`], and [`track`] sub-commands, even
+   when cheats are not enabled. The [`tp`] and [`view`] commands require cheats.
+
+If a permission mod such as [LuckPerms] is installed[^permission], you can configure access to the individual
+sub-commands. Each sub-command creates a `computercraft.command.NAME` permission node to control which players can
+execute it.
+
+[LuckPerms]: https://github.com/LuckPerms/LuckPerms/ "A permissions plugin for Minecraft servers."
+[fabric-permission-api]: https://github.com/lucko/fabric-permissions-api "A simple permissions API for Fabric"
+
+[^permission]: This supports any mod which uses Forge's permission API or [fabric-permission-api].
+
+## Computer selectors {#computer-selectors}
+Some commands (such as [`tp`] or [`turn-on`]) target a specific computer, or a list of computers. To specify which
+computers to operate on, you must use "computer selectors".
+
+Computer selectors are similar to Minecraft's [entity target selectors], but targeting computers instead. They allow
+you to select one or more computers, based on a set of predicates.
+
+The following predicates are supported:
+ - `id=<id>`: Select computer(s) with a specific id.
+ - `instance=<id>`: Select the computer with the given instance id.
+ - `family=<normal|advanced|command>`: Select computers based on their type.
+ - `label=<label>`: Select computers with the given label.
+ - `distance=<distance>`: Select computers within a specific distance of the player executing the command. This uses
+   Minecraft's [float range] syntax.
+
+`#<id>` may also be used as a shorthand for `@c[id=<id>]`, to select computer(s) with a specific id.
+
+### Examples:
+ - `/computercraft turn-on #12`: Turn on the computer(s) with an id of 12.
+ - `/computercraft shutdown @c[distance=..100]`: Shut down all computers with 100 blocks of the player.
+
+[entity target selectors]: https://minecraft.wiki/w/Target_selectors "Target Selectors on the Minecraft wiki"
+[Float range]: https://minecraft.wiki/w/Argument_types#minecraft:float_range
+
+## Commands {#commands}
+### `/computercraft dump` {#dump}
+`/computercraft dump` prints a table of currently loaded computers, including their id, position, and whether they're
+running. It can also be run with a single computer argument to dump more detailed information about a computer.
+
+![A screenshot of a Minecraft world. In the chat box, there is a table listing 5 computers, with columns labelled
+"Computer", "On" and "Position". Below that, is a more detailed list of information about Computer 0, including its
+label ("My computer") and that it has a monitor on the right hand side](../images/computercraft-dump.png "An example of
+running '/computercraft dump'")
+
+Next to the computer id, there are several buttons to either [teleport][`tp`] to the computer, or [open its terminal
+][`view`].
+
+ Computers are sorted by distance to the player, so nearby computers will appear earlier.
+
+### `/computercraft turn-on [computers...]` {#turn-on}
+Turn on one or more computers or, if no run with no arguments, all loaded computers.
+
+#### Examples
+ - `/computercraft turn-on #0 #2`: Turn on computers with id 0 and 2.
+ - `/computercraft turn-on @c[family=command]`: Turn on all command computers.
+
+### `/computercraft shutdown [computers...]` {#shutdown}
+Shutdown one or more computers or, if no run with no arguments, all loaded computers.
+
+This is sometimes useful when dealing with lag, as a way to ensure that ComputerCraft is not causing problems.
+
+#### Examples
+ - `/computercraft shutdown`: Shut down all loaded computers.
+ - `/computercraft shutdown @c[distance=..10]`: Shut down all computers in a block radius.
+
+### `/computercraft tp [computer]` {#tp}
+Teleport to the given computer.
+
+This is normally used from via the [`dump`] command interface rather than being invoked directly.
+
+### `/computercraft view [computer]` {#view}
+Open a terminal for the specified computer. This allows remotely viewing computers without having to interact with the
+block.
+
+This is normally used from via the [`dump`] command interface rather than being invoked directly.
+
+### `/computercraft track` {#track}
+The `/computercraft track` command allows you to enable profiling of computers. When a computer runs code, or interacts
+with the Minecraft world, we time how long that takes. This timing information may then be queried, and used to find
+computers which may be causing lag.
+
+To enable the profiler, run `/computercraft track start`. Computers will then start recording metrics. Once enough data
+has been gathered, run `/computercraft track stop` to stop profiling and display the recorded data.
+
+![](../images/computercraft-track.png)
+
+The table by default shows the number of times each computer has run, and how long it ran for (in total, and on
+average). In the above screenshot, we can see one computer was particularly badly behaved, and ran for 7 seconds. The
+buttons may be used to [teleport][`tp`] to the computer, or [open its terminal ][`view`], and inspect it further.
+
+`/computercraft track dump` can be used to display this table at any point (including while profiling is still running).
+
+Computers also record other information, such as how much server-thread time they consume, or their HTTP bandwidth
+usage. The `dump` subcommand accepts a list of other fields to display, instead of the default timings.
+
+#### Examples
+ - `/computercraft track dump server_tasks_count server_tasks`: Print the number of server-thread tasks each computer
+   executed, and how long they took in total.
+ - `/computercraft track dump http_upload http_download`: Print the number of bytes uploaded and downloaded by each
+   computer.
+
+
+### `/computercraft queue` {#queue}
+The queue subcommand allows non-operator players to queue a `computer_command` event on *command* computers.
+
+This has a similar purpose to vanilla's [`/trigger`] command. Command computers may choose to listen to this event, and
+then perform some action.
+
+[`/trigger`]: https://minecraft.wiki/w/Commands/trigger "/trigger on the Minecraft wiki"
+
+
+[`dump`]: #dump "/computercraft dump"
+[`queue`]: #queue "/computercraft queue"
+[`shutdown`]: #shutdown "/computercraft shutdown"
+[`tp`]: #tp "/computercraft tp"
+[`track`]: #track "/computercraft track"
+[`turn-on`]: #turn-on "/computercraft turn-on"
+[`view`]: #view "/computercraft view"
+[computer selectors]: #computer-selectors "Computer selectors"

gradle.properties

@@ -2,15 +2,17 @@
 #
 # SPDX-License-Identifier: MPL-2.0
 
-org.gradle.jvmargs=-Xmx3G
+org.gradle.jvmargs=-Xmx3G -Dfile.encoding=UTF-8
 org.gradle.parallel=true
 
 kotlin.stdlib.default.dependency=false
 kotlin.jvm.target.validation.mode=error
 
+neogradle.subsystems.conventions.runs.enabled=false
+
 # Mod properties
 isUnstable=true
-modVersion=1.109.0
+modVersion=1.111.0
 
 # Minecraft properties: We want to configure this here so we can read it in settings.gradle
-mcVersion=1.20.1
+mcVersion=1.21

gradle/libs.versions.toml

@@ -6,71 +6,74 @@
 
 # Minecraft
 # MC version is specified in gradle.properties, as we need that in settings.gradle.
-# Remember to update corresponding versions in fabric.mod.json/mods.toml
-fabric-api = "0.86.1+1.20.1"
-fabric-loader = "0.14.21"
-forge = "47.1.0"
-forgeSpi = "6.0.0"
+# Remember to update corresponding versions in fabric.mod.json/neoforge.mods.toml
+fabric-api = "0.100.3+1.21"
+fabric-loader = "0.15.11"
+neoForge = "21.0.21-beta"
+neoForgeSpi = "8.0.1"
 mixin = "0.8.5"
-parchment = "2023.08.20"
-parchmentMc = "1.20.1"
+parchment = "2024.06.16"
+parchmentMc = "1.20.6"
+yarn = "1.21+build.1"
 
-# Normal dependencies
-asm = "9.5"
+# Core dependencies (these versions are tied to the version Minecraft uses)
+fastutil = "8.5.12"
+guava = "32.1.2-jre"
+netty = "4.1.97.Final"
+slf4j = "2.0.9"
+
+# Core dependencies (independent of Minecraft)
+asm = "9.6"
 autoService = "1.1.1"
-checkerFramework = "3.32.0"
-cobalt = "0.8.0"
-cobalt-next = "0.8.1" # Not a real version, used to constrain the version we accept.
-commonsCli = "1.3.1"
-fastutil = "8.5.9"
-guava = "31.1-jre"
-jetbrainsAnnotations = "24.0.1"
+checkerFramework = "3.42.0"
+cobalt = { strictly = "0.9.3" }
+commonsCli = "1.6.0"
+jetbrainsAnnotations = "24.1.0"
 jsr305 = "3.0.2"
 jzlib = "1.1.3"
-kotlin = "1.8.10"
-kotlin-coroutines = "1.6.4"
-netty = "4.1.82.Final"
+kotlin = "1.9.21"
+kotlin-coroutines = "1.7.3"
 nightConfig = "3.6.7"
-slf4j = "2.0.1"
 
 # Minecraft mods
-emi = "1.0.8+1.20.1"
-fabricPermissions = "0.3.20230723"
-iris = "1.6.4+1.20"
-jei = "15.2.0.22"
-modmenu = "7.1.0"
+emi = "1.1.7+1.21"
+fabricPermissions = "0.3.1"
+iris = "1.6.14+1.20.4"
+jei = "19.0.0.1"
+modmenu = "11.0.0-rc.4"
 moreRed = "4.0.0.4"
 oculus = "1.2.5"
-rei = "12.0.626"
+rei = "16.0.729"
 rubidium = "0.6.1"
 sodium = "mc1.20-0.4.10"
+mixinExtra = "0.3.5"
 
 # Testing
 hamcrest = "2.2"
-jqwik = "1.7.4"
-junit = "5.10.0"
+jqwik = "1.8.2"
+junit = "5.10.1"
+jmh = "1.37"
 
 # Build tools
-cctJavadoc = "1.8.1"
-checkstyle = "10.12.3"
-curseForgeGradle = "1.0.14"
-errorProne-core = "2.21.1"
+cctJavadoc = "1.8.2"
+checkstyle = "10.14.1"
+curseForgeGradle = "1.1.18"
+errorProne-core = "2.27.0"
 errorProne-plugin = "3.1.0"
-fabric-loom = "1.3.7"
-forgeGradle = "6.0.8"
-githubRelease = "2.4.1"
+fabric-loom = "1.6.7"
+githubRelease = "2.5.2"
+gradleVersions = "0.50.0"
 ideaExt = "1.1.7"
-illuaminate = "0.1.0-44-g9ee0055"
-librarian = "1.+"
-lwjgl = "3.3.1"
-minotaur = "2.+"
-mixinGradle = "0.7.+"
-nullAway = "0.9.9"
-spotless = "6.21.0"
+illuaminate = "0.1.0-73-g43ee16c"
+lwjgl = "3.3.3"
+minotaur = "2.8.7"
+neoGradle = "7.0.145"
+nullAway = "0.10.25"
+spotless = "6.23.3"
 taskTree = "2.1.1"
-teavm = "0.10.0-SQUID.1"
-vanillaGradle = "0.2.1-SNAPSHOT"
-vineflower = "1.11.0"
+teavm = "0.10.0-SQUID.4"
+vanillaExtract = "0.1.3"
+versionCatalogUpdate = "0.8.1"
 
 [libraries]
 # Normal dependencies
@@ -81,7 +84,7 @@ checkerFramework = { module = "org.checkerframework:checker-qual", version.ref =
 cobalt = { module = "cc.tweaked:cobalt", version.ref = "cobalt" }
 commonsCli = { module = "commons-cli:commons-cli", version.ref = "commonsCli" }
 fastutil = { module = "it.unimi.dsi:fastutil", version.ref = "fastutil" }
-forgeSpi = { module = "net.minecraftforge:forgespi", version.ref = "forgeSpi" }
+neoForgeSpi = { module = "net.neoforged:neoforgespi", version.ref = "neoForgeSpi" }
 guava = { module = "com.google.guava:guava", version.ref = "guava" }
 jetbrainsAnnotations = { module = "org.jetbrains:annotations", version.ref = "jetbrainsAnnotations" }
 jsr305 = { module = "com.google.code.findbugs:jsr305", version.ref = "jsr305" }
@@ -103,10 +106,11 @@ fabric-junit = { module = "net.fabricmc:fabric-loader-junit", version.ref = "fab
 fabricPermissions = { module = "me.lucko:fabric-permissions-api", version.ref = "fabricPermissions" }
 emi = { module = "dev.emi:emi-xplat-mojmap", version.ref = "emi" }
 iris = { module = "maven.modrinth:iris", version.ref = "iris" }
-jei-api = { module = "mezz.jei:jei-1.20.1-common-api", version.ref = "jei" }
-jei-fabric = { module = "mezz.jei:jei-1.20.1-fabric", version.ref = "jei" }
-jei-forge = { module = "mezz.jei:jei-1.20.1-forge", version.ref = "jei" }
+jei-api = { module = "mezz.jei:jei-1.21-common-api", version.ref = "jei" }
+jei-fabric = { module = "mezz.jei:jei-1.21-fabric", version.ref = "jei" }
+jei-forge = { module = "mezz.jei:jei-1.21-neoforge", version.ref = "jei" }
 mixin = { module = "org.spongepowered:mixin", version.ref = "mixin" }
+mixinExtra = { module = "io.github.llamalad7:mixinextras-common", version.ref = "mixinExtra" }
 modmenu = { module = "com.terraformersmc:modmenu", version.ref = "modmenu" }
 moreRed = { module = "commoble.morered:morered-1.20.1", version.ref = "moreRed" }
 oculus = { module = "maven.modrinth:oculus", version.ref = "oculus" }
@@ -124,6 +128,8 @@ junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.re
 junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
 junit-jupiter-params = { module = "org.junit.jupiter:junit-jupiter-params", version.ref = "junit" }
 slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
+jmh = { module = "org.openjdk.jmh:jmh-core", version.ref = "jmh" }
+jmh-processor = { module = "org.openjdk.jmh:jmh-generator-annprocess", version.ref = "jmh" }
 
 # LWJGL
 lwjgl-bom = { module = "org.lwjgl:lwjgl-bom", version.ref = "lwjgl" }
@@ -141,14 +147,14 @@ errorProne-core = { module = "com.google.errorprone:error_prone_core", version.r
 errorProne-plugin = { module = "net.ltgt.gradle:gradle-errorprone-plugin", version.ref = "errorProne-plugin" }
 errorProne-testHelpers = { module = "com.google.errorprone:error_prone_test_helpers", version.ref = "errorProne-core" }
 fabric-loom = { module = "net.fabricmc:fabric-loom", version.ref = "fabric-loom" }
-forgeGradle = { module = "net.minecraftforge.gradle:ForgeGradle", version.ref = "forgeGradle" }
 ideaExt = { module = "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext", version.ref = "ideaExt" }
 kotlin-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
-librarian = { module = "org.parchmentmc:librarian", version.ref = "librarian" }
 minotaur = { module = "com.modrinth.minotaur:Minotaur", version.ref = "minotaur" }
+neoGradle-userdev = { module = "net.neoforged.gradle:userdev", version.ref = "neoGradle" }
 nullAway = { module = "com.uber.nullaway:nullaway", version.ref = "nullAway" }
 spotless = { module = "com.diffplug.spotless:spotless-plugin-gradle", version.ref = "spotless" }
 teavm-classlib = { module = "org.teavm:teavm-classlib", version.ref = "teavm" }
+teavm-core = { module = "org.teavm:teavm-core", version.ref = "teavm" }
 teavm-jso = { module = "org.teavm:teavm-jso", version.ref = "teavm" }
 teavm-jso-apis = { module = "org.teavm:teavm-jso-apis", version.ref = "teavm" }
 teavm-jso-impl = { module = "org.teavm:teavm-jso-impl", version.ref = "teavm" }
@@ -156,16 +162,15 @@ teavm-metaprogramming-api = { module = "org.teavm:teavm-metaprogramming-api", ve
 teavm-metaprogramming-impl = { module = "org.teavm:teavm-metaprogramming-impl", version.ref = "teavm" }
 teavm-platform = { module = "org.teavm:teavm-platform", version.ref = "teavm" }
 teavm-tooling = { module = "org.teavm:teavm-tooling", version.ref = "teavm" }
-vanillaGradle = { module = "org.spongepowered:vanillagradle", version.ref = "vanillaGradle" }
-vineflower = { module = "io.github.juuxel:loom-vineflower", version.ref = "vineflower" }
+vanillaExtract = { module = "cc.tweaked.vanilla-extract:plugin", version.ref = "vanillaExtract" }
+yarn = { module = "net.fabricmc:yarn", version.ref = "yarn" }
 
 [plugins]
-forgeGradle = { id = "net.minecraftforge.gradle", version.ref = "forgeGradle" }
 githubRelease = { id = "com.github.breadmoirai.github-release", version.ref = "githubRelease" }
+gradleVersions = { id = "com.github.ben-manes.versions", version.ref = "gradleVersions" }
 kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
-librarian = { id = "org.parchmentmc.librarian.forgegradle", version.ref = "librarian" }
-mixinGradle = { id = "org.spongepowered.mixin", version.ref = "mixinGradle" }
 taskTree = { id = "com.dorongold.task-tree", version.ref = "taskTree" }
+versionCatalogUpdate = { id = "nl.littlerobots.version-catalog-update", version.ref = "versionCatalogUpdate" }
 
 [bundles]
 annotations = ["jsr305", "checkerFramework", "jetbrainsAnnotations"]
@@ -175,7 +180,6 @@ kotlin = ["kotlin-stdlib", "kotlin-coroutines"]
 externalMods-common = ["jei-api", "nightConfig-core", "nightConfig-toml"]
 externalMods-forge-compile = ["moreRed", "oculus", "jei-api"]
 externalMods-forge-runtime = ["jei-forge"]
-externalMods-fabric = ["nightConfig-core", "nightConfig-toml"]
 externalMods-fabric-compile = ["fabricPermissions", "iris", "jei-api", "rei-api", "rei-builtin"]
 externalMods-fabric-runtime = ["jei-fabric", "modmenu"]
 
@@ -184,5 +188,5 @@ test = ["junit-jupiter-api", "junit-jupiter-params", "hamcrest", "jqwik-api"]
 testRuntime = ["junit-jupiter-engine", "jqwik-engine"]
 
 # Build tools
-teavm-api = [ "teavm-jso", "teavm-jso-apis", "teavm-platform", "teavm-classlib", "teavm-metaprogramming-api" ]
-teavm-tooling = [ "teavm-tooling", "teavm-metaprogramming-impl", "teavm-jso-impl" ]
+teavm-api = ["teavm-jso", "teavm-jso-apis", "teavm-platform", "teavm-classlib", "teavm-metaprogramming-api"]
+teavm-tooling = ["teavm-tooling", "teavm-metaprogramming-impl", "teavm-jso-impl"]

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
 networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -83,7 +83,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -130,10 +131,13 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -141,7 +145,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -149,7 +153,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -198,11 +202,11 @@ fi
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

gradlew.bat

@@ -43,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 

illuaminate.sexp

@@ -6,7 +6,7 @@
 
 (sources
   /doc/
-  /projects/forge/build/docs/luaJavadoc/
+  /projects/common/build/docs/luaJavadoc/
   /projects/core/src/main/resources/data/computercraft/lua/bios.lua
   /projects/core/src/main/resources/data/computercraft/lua/rom/
   /projects/core/src/test/resources/test-rom
@@ -36,7 +36,7 @@
 
   (library-path
     /doc/stub/
-    /projects/forge/build/docs/luaJavadoc/
+    /projects/common/build/docs/luaJavadoc/
 
     /projects/core/src/main/resources/data/computercraft/lua/rom/apis/
     /projects/core/src/main/resources/data/computercraft/lua/rom/apis/command/
@@ -88,7 +88,7 @@
   (/doc/stub/
    /projects/core/src/main/resources/data/computercraft/lua/bios.lua
    /projects/core/src/main/resources/data/computercraft/lua/rom/apis/
-   /projects/forge/build/docs/luaJavadoc/)
+   /projects/common/build/docs/luaJavadoc/)
   (linters -var:unused-global)
   (lint (allow-toplevel-global true)))
 
@@ -105,6 +105,10 @@
    /projects/core/src/main/resources/data/computercraft/lua/rom/apis/turtle/turtle.lua)
   (linters -var:deprecated))
 
+;; Suppress unused variable warnings in the parser.
+(at /projects/core/src/main/resources/data/computercraft/lua/rom/modules/main/cc/internal/syntax/parser.lua
+  (linters -var:unused))
+
 (at /projects/core/src/test/resources/test-rom
   ; We should still be able to test deprecated members.
   (linters -var:deprecated)

package.json

@@ -23,7 +23,7 @@
     "rehype-highlight": "^7.0.0",
     "rehype-react": "^8.0.0",
     "rollup": "^4.0.0",
-    "tsx": "^3.12.10",
+    "tsx": "^4.7.0",
     "typescript": "^5.2.2"
   }
 }

projects/common-api/build.gradle.kts

@@ -21,4 +21,16 @@ tasks.javadoc {
 
     // Include the core-api in our javadoc export. This is wrong, but it means we can export a single javadoc dump.
     source(project(":core-api").sourceSets.main.map { it.allJava })
+
+    options {
+        this as StandardJavadocDocletOptions
+        addBooleanOption("-allow-script-in-comments", true)
+        bottom(
+            """
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/components/prism-core.min.js"></script>
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/plugins/autoloader/prism-autoloader.min.js"></script>
+            <link href=" https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism.min.css " rel="stylesheet">
+            """.trimIndent(),
+        )
+    }
 }

projects/common-api/src/client/java/dan200/computercraft/api/client/ComputerCraftAPIClient.java

@@ -1,38 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.client;
-
-import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
-import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.impl.client.ComputerCraftAPIClientService;
-
-/**
- * The public API for client-only code.
- *
- * @see dan200.computercraft.api.ComputerCraftAPI The main API
- */
-public final class ComputerCraftAPIClient {
-    private ComputerCraftAPIClient() {
-    }
-
-    /**
-     * Register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
-     * <p>
-     * This may be called at any point after registry creation, though it is recommended to call it within your client
-     * setup step.
-     *
-     * @param serialiser The turtle upgrade serialiser.
-     * @param modeller   The upgrade modeller.
-     * @param <T>        The type of the turtle upgrade.
-     */
-    public static <T extends ITurtleUpgrade> void registerTurtleUpgradeModeller(TurtleUpgradeSerialiser<T> serialiser, TurtleUpgradeModeller<T> modeller) {
-        getInstance().registerTurtleUpgradeModeller(serialiser, modeller);
-    }
-
-    private static ComputerCraftAPIClientService getInstance() {
-        return ComputerCraftAPIClientService.get();
-    }
-}

projects/common-api/src/client/java/dan200/computercraft/api/client/ModelLocation.java

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client;
+
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import dan200.computercraft.impl.client.ClientPlatformHelper;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.client.resources.model.ModelManager;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.stream.Stream;
+
+/**
+ * The location of a model to load. This may either be:
+ *
+ * <ul>
+ *     <li>A {@link ModelResourceLocation}, referencing an already baked model (such as {@code minecraft:dirt#inventory}).</li>
+ *     <li>
+ *         A {@link ResourceLocation}, referencing a path to a model resource (such as {@code minecraft:item/dirt}.
+ *         These models will be baked and stored in the {@link ModelManager} in a loader-specific way.
+ *     </li>
+ * </ul>
+ */
+public final class ModelLocation {
+    /**
+     * The location of the model.
+     * <p>
+     * When {@link #resourceLocation} is null, this is the location of the model to load. When {@link #resourceLocation}
+     * is non-null, this is the "standalone" variant of the model resource — this is used by NeoForge's implementation
+     * of {@link ClientPlatformHelper#getModel(ModelManager, ModelResourceLocation, ResourceLocation)} to fetch the
+     * model from the model manger. It is not used on Fabric.
+     */
+    private final ModelResourceLocation modelLocation;
+    private final @Nullable ResourceLocation resourceLocation;
+
+    private ModelLocation(ModelResourceLocation modelLocation, @Nullable ResourceLocation resourceLocation) {
+        this.modelLocation = modelLocation;
+        this.resourceLocation = resourceLocation;
+    }
+
+    /**
+     * Create a {@link ModelLocation} from model in the model manager.
+     *
+     * @param location The name of the model to load.
+     * @return The new {@link ModelLocation} instance.
+     */
+    public static ModelLocation ofModel(ModelResourceLocation location) {
+        return new ModelLocation(location, null);
+    }
+
+    /**
+     * Create a {@link ModelLocation} from a resource.
+     *
+     * @param location The location of the model resource, such as {@code minecraft:item/dirt}.
+     * @return The new {@link ModelLocation} instance.
+     */
+    public static ModelLocation ofResource(ResourceLocation location) {
+        return new ModelLocation(new ModelResourceLocation(location, "standalone"), location);
+    }
+
+    /**
+     * Get this model from the provided model manager.
+     *
+     * @param manager The model manger.
+     * @return This model, or the missing model if it could not be found.
+     */
+    public BakedModel getModel(ModelManager manager) {
+        return ClientPlatformHelper.get().getModel(manager, modelLocation, resourceLocation);
+    }
+
+    /**
+     * Get the models this model location depends on.
+     *
+     * @return A list of models that this model location depends on.
+     * @see TurtleUpgradeModeller#getDependencies()
+     */
+    public Stream<ResourceLocation> getDependencies() {
+        return resourceLocation == null ? Stream.empty() : Stream.of(resourceLocation);
+    }
+}

projects/common-api/src/client/java/dan200/computercraft/api/client/TransformedModel.java

@@ -13,30 +13,47 @@ import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;
 
-import java.util.Objects;
-
 /**
  * A model to render, combined with a transformation matrix to apply.
+ *
+ * @param model  The model.
+ * @param matrix The transformation matrix.
  */
-public final class TransformedModel {
-    private final BakedModel model;
-    private final Transformation matrix;
-
-    public TransformedModel(BakedModel model, Transformation matrix) {
-        this.model = Objects.requireNonNull(model);
-        this.matrix = Objects.requireNonNull(matrix);
-    }
-
+public record TransformedModel(BakedModel model, Transformation matrix) {
     public TransformedModel(BakedModel model) {
-        this.model = Objects.requireNonNull(model);
-        matrix = Transformation.identity();
+        this(model, Transformation.identity());
     }
 
+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     */
+    public static TransformedModel of(ModelLocation location) {
+        var modelManager = Minecraft.getInstance().getModelManager();
+        return new TransformedModel(location.getModel(modelManager));
+    }
+
+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     * @see ModelLocation#ofModel(ModelResourceLocation)
+     */
     public static TransformedModel of(ModelResourceLocation location) {
         var modelManager = Minecraft.getInstance().getModelManager();
         return new TransformedModel(modelManager.getModel(location));
     }
 
+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     * @see ModelLocation#ofResource(ResourceLocation)
+     */
     public static TransformedModel of(ResourceLocation location) {
         var modelManager = Minecraft.getInstance().getModelManager();
         return new TransformedModel(ClientPlatformHelper.get().getModel(modelManager, location));
@@ -46,12 +63,4 @@ public final class TransformedModel {
         var model = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getItemModel(item);
         return new TransformedModel(model, transform);
     }
-
-    public BakedModel getModel() {
-        return model;
-    }
-
-    public Transformation getMatrix() {
-        return matrix;
-    }
 }

projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/RegisterTurtleUpgradeModeller.java

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client.turtle;
+
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.upgrades.UpgradeType;
+
+/**
+ * A functional interface to register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
+ * <p>
+ * This interface is largely intended to be used from multi-loader code, to allow sharing registration code between
+ * multiple loaders.
+ */
+@FunctionalInterface
+public interface RegisterTurtleUpgradeModeller {
+    /**
+     * Register a {@link TurtleUpgradeModeller}.
+     *
+     * @param type     The turtle upgrade type.
+     * @param modeller The upgrade modeller.
+     * @param <T>      The type of the turtle upgrade.
+     */
+    <T extends ITurtleUpgrade> void register(UpgradeType<T> type, TurtleUpgradeModeller<T> modeller);
+}

projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModeller.java

@@ -4,72 +4,58 @@
 
 package dan200.computercraft.api.client.turtle;
 
-import dan200.computercraft.api.client.ComputerCraftAPIClient;
+import dan200.computercraft.api.client.ModelLocation;
 import dan200.computercraft.api.client.TransformedModel;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.client.resources.model.UnbakedModel;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.resources.ResourceLocation;
 
 import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Provides models for a {@link ITurtleUpgrade}.
+ * <p>
+ * Use {@code dan200.computercraft.api.client.FabricComputerCraftAPIClient#registerTurtleUpgradeModeller} to register a
+ * modeller on Fabric and {@code dan200.computercraft.api.client.turtle.RegisterTurtleModellersEvent} to register one
+ * on Forge
  *
  * @param <T> The type of turtle upgrade this modeller applies to.
- * @see ComputerCraftAPIClient#registerTurtleUpgradeModeller(TurtleUpgradeSerialiser, TurtleUpgradeModeller) To register a modeller.
+ * @see RegisterTurtleUpgradeModeller For multi-loader registration support.
  */
 public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
     /**
      * Obtain the model to be used when rendering a turtle peripheral.
      * <p>
-     * When the current turtle is {@literal null}, this function should be constant for a given upgrade and side.
+     * When the current turtle is {@literal null}, this function should be constant for a given upgrade, side and data.
      *
      * @param upgrade The upgrade that you're getting the model for.
-     * @param turtle  Access to the turtle that the upgrade resides on. This will be null when getting item models, unless
-     *                {@link #getModel(ITurtleUpgrade, CompoundTag, TurtleSide)} is overriden.
+     * @param turtle  Access to the turtle that the upgrade resides on. This will be null when getting item models.
      * @param side    Which side of the turtle (left or right) the upgrade resides on.
-     * @return The model that you wish to be used to render your upgrade.
-     */
-    TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side);
-
-    /**
-     * Obtain the model to be used when rendering a turtle peripheral.
-     * <p>
-     * This is used when rendering the turtle's item model, and so no {@link ITurtleAccess} is available.
-     *
-     * @param upgrade The upgrade that you're getting the model for.
      * @param data    Upgrade data instance for current turtle side.
-     * @param side    Which side of the turtle (left or right) the upgrade resides on.
      * @return The model that you wish to be used to render your upgrade.
      */
-    default TransformedModel getModel(T upgrade, CompoundTag data, TurtleSide side) {
-        return getModel(upgrade, (ITurtleAccess) null, side);
-    }
-
+    TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data);
 
     /**
-     * Get a list of models that this turtle modeller depends on.
+     * Get the models that this turtle modeller depends on.
      * <p>
-     * Models included in this list will be loaded and baked alongside item and block models, and so may be referenced
+     * Models included in this stream will be loaded and baked alongside item and block models, and so may be referenced
      * by {@link TransformedModel#of(ResourceLocation)}. You do not need to override this method if you will load models
      * by other means.
      *
      * @return A list of models that this modeller depends on.
      * @see UnbakedModel#getDependencies()
      */
-    default Collection<ResourceLocation> getDependencies() {
-        return List.of();
+    default Stream<ResourceLocation> getDependencies() {
+        return Stream.of();
     }
 
     /**
-     * A basic {@link TurtleUpgradeModeller} which renders using the upgrade's {@linkplain ITurtleUpgrade#getUpgradeItem(CompoundTag)}
+     * A basic {@link TurtleUpgradeModeller} which renders using the upgrade's {@linkplain ITurtleUpgrade#getUpgradeItem(DataComponentPatch)}
      * upgrade item}.
      * <p>
      * This uses appropriate transformations for "flat" items, namely those extending the {@literal minecraft:item/generated}
@@ -91,9 +77,8 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
      * @param <T>   The type of the turtle upgrade.
      * @return The constructed modeller.
      */
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ModelResourceLocation left, ModelResourceLocation right) {
-        // TODO(1.21.0): Remove this.
-        return sided((ResourceLocation) left, right);
+    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ResourceLocation left, ResourceLocation right) {
+        return sided(ModelLocation.ofResource(left), ModelLocation.ofResource(right));
     }
 
     /**
@@ -104,16 +89,16 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
      * @param <T>   The type of the turtle upgrade.
      * @return The constructed modeller.
      */
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ResourceLocation left, ResourceLocation right) {
+    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ModelLocation left, ModelLocation right) {
         return new TurtleUpgradeModeller<>() {
             @Override
-            public TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side) {
+            public TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data) {
                 return TransformedModel.of(side == TurtleSide.LEFT ? left : right);
             }
 
             @Override
-            public Collection<ResourceLocation> getDependencies() {
-                return List.of(left, right);
+            public Stream<ResourceLocation> getDependencies() {
+                return Stream.of(left, right).flatMap(ModelLocation::getDependencies);
             }
         };
     }

projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModellers.java

@@ -11,8 +11,7 @@ import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
 import dan200.computercraft.impl.client.ClientPlatformHelper;
 import net.minecraft.client.Minecraft;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.world.item.ItemStack;
+import net.minecraft.core.component.DataComponentPatch;
 import org.joml.Matrix4f;
 
 import javax.annotation.Nullable;
@@ -37,16 +36,8 @@ final class TurtleUpgradeModellers {
 
     private static final class UpgradeItemModeller implements TurtleUpgradeModeller<ITurtleUpgrade> {
         @Override
-        public TransformedModel getModel(ITurtleUpgrade upgrade, @Nullable ITurtleAccess turtle, TurtleSide side) {
-            return getModel(turtle == null ? upgrade.getCraftingItem() : upgrade.getUpgradeItem(turtle.getUpgradeNBTData(side)), side);
-        }
-
-        @Override
-        public TransformedModel getModel(ITurtleUpgrade upgrade, CompoundTag data, TurtleSide side) {
-            return getModel(upgrade.getUpgradeItem(data), side);
-        }
-
-        private TransformedModel getModel(ItemStack stack, TurtleSide side) {
+        public TransformedModel getModel(ITurtleUpgrade upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data) {
+            var stack = upgrade.getUpgradeItem(data);
             var model = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getItemModel(stack);
             if (stack.hasFoil()) model = ClientPlatformHelper.get().createdFoiledModel(model);
             return new TransformedModel(model, side == TurtleSide.LEFT ? leftTransform : rightTransform);

projects/common-api/src/client/java/dan200/computercraft/impl/client/ClientPlatformHelper.java

@@ -4,6 +4,7 @@
 
 package dan200.computercraft.impl.client;
 
+import dan200.computercraft.api.client.ModelLocation;
 import dan200.computercraft.impl.Services;
 import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.resources.model.BakedModel;
@@ -17,13 +18,28 @@ import javax.annotation.Nullable;
 @ApiStatus.Internal
 public interface ClientPlatformHelper {
     /**
-     * Equivalent to {@link ModelManager#getModel(ModelResourceLocation)} but for arbitrary {@link ResourceLocation}s.
+     * Get a model from a resource.
      *
-     * @param manager  The model manager.
-     * @param location The model location.
+     * @param manager          The model manager.
+     * @param resourceLocation The model resourceLocation.
      * @return The baked model.
+     * @see ModelLocation
      */
-    BakedModel getModel(ModelManager manager, ResourceLocation location);
+    BakedModel getModel(ModelManager manager, ResourceLocation resourceLocation);
+
+    /**
+     * Set a model from a {@link ModelResourceLocation} or {@link ResourceLocation}.
+     * <p>
+     * This is largely equivalent to {@code resourceLocation == null ? manager.getModel(modelLocation) : getModel(manager, resourceLocation)},
+     * but allows pre-computing {@code modelLocation} (if needed).
+     *
+     * @param manager          The model manager.
+     * @param modelLocation    The location of the model to load.
+     * @param resourceLocation The location of the resource, if trying to load from a resource.
+     * @return The baked model.
+     * @see ModelLocation
+     */
+    BakedModel getModel(ModelManager manager, ModelResourceLocation modelLocation, @Nullable ResourceLocation resourceLocation);
 
     /**
      * Wrap this model in a version which renders a foil/enchantment glint.

projects/common-api/src/main/java/dan200/computercraft/api/ComputerCraftTags.java

@@ -6,10 +6,12 @@ package dan200.computercraft.api;
 
 import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.ItemTags;
 import net.minecraft.tags.TagKey;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.context.UseOnContext;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
@@ -35,8 +37,16 @@ public class ComputerCraftTags {
          */
         public static final TagKey<Item> TURTLE_CAN_PLACE = make("turtle_can_place");
 
+        /**
+         * Items which can be dyed.
+         * <p>
+         * This is similar to {@link ItemTags#DYEABLE}, but allows cleaning the item with a sponge, rather than in a
+         * cauldron.
+         */
+        public static final TagKey<Item> DYEABLE = make("dyeable");
+
         private static TagKey<Item> make(String name) {
-            return TagKey.create(Registries.ITEM, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
+            return TagKey.create(Registries.ITEM, ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name));
         }
     }
 
@@ -75,13 +85,13 @@ public class ComputerCraftTags {
         public static final TagKey<Block> TURTLE_HOE_BREAKABLE = make("turtle_hoe_harvestable");
 
         /**
-         * Block which can be {@linkplain BlockState#use(Level, Player, InteractionHand, BlockHitResult) used} when
-         * calling {@code turtle.place()}.
+         * Block which can be {@linkplain BlockState#useItemOn(ItemStack, Level, Player, InteractionHand, BlockHitResult) used}
+         * when calling {@code turtle.place()}.
          */
         public static final TagKey<Block> TURTLE_CAN_USE = make("turtle_can_use");
 
         private static TagKey<Block> make(String name) {
-            return TagKey.create(Registries.BLOCK, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
+            return TagKey.create(Registries.BLOCK, ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name));
         }
     }
 }

projects/common-api/src/main/java/dan200/computercraft/api/media/IMedia.java

@@ -7,11 +7,13 @@ package dan200.computercraft.api.media;
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.filesystem.Mount;
 import dan200.computercraft.api.filesystem.WritableMount;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
-import net.minecraft.sounds.SoundEvent;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.JukeboxSong;
 
 import javax.annotation.Nullable;
 
@@ -25,11 +27,12 @@ public interface IMedia {
     /**
      * Get a string representing the label of this item. Will be called via {@code disk.getLabel()} in lua.
      *
-     * @param stack The {@link ItemStack} to inspect.
+     * @param registries The currently loaded registries.
+     * @param stack      The {@link ItemStack} to inspect.
      * @return The label. ie: "Dan's Programs".
      */
     @Nullable
-    String getLabel(ItemStack stack);
+    String getLabel(HolderLookup.Provider registries, ItemStack stack);
 
     /**
      * Set a string representing the label of this item. Will be called vi {@code disk.setLabel()} in lua.
@@ -43,26 +46,15 @@ public interface IMedia {
     }
 
     /**
-     * If this disk represents an item with audio (like a record), get the readable name of the audio track. ie:
-     * "Jonathan Coulton - Still Alive"
+     * If this disk represents an item with audio (like a record), get the corresponding {@link JukeboxSong}.
      *
-     * @param stack The {@link ItemStack} to modify.
-     * @return The name, or null if this item does not represent an item with audio.
+     * @param registries The currently loaded registries.
+     * @param stack      The {@link ItemStack} to query.
+     * @return The song, or null if this item does not represent an item with audio.
      */
     @Nullable
-    default String getAudioTitle(ItemStack stack) {
-        return null;
-    }
-
-    /**
-     * If this disk represents an item with audio (like a record), get the resource name of the audio track to play.
-     *
-     * @param stack The {@link ItemStack} to modify.
-     * @return The name, or null if this item does not represent an item with audio.
-     */
-    @Nullable
-    default SoundEvent getAudio(ItemStack stack) {
-        return null;
+    default Holder<JukeboxSong> getAudio(HolderLookup.Provider registries, ItemStack stack) {
+        return JukeboxSong.fromStack(registries, stack).orElse(null);
     }
 
     /**

projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNetwork.java

@@ -1,82 +0,0 @@
-// SPDX-FileCopyrightText: 2018 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.network.wired;
-
-import dan200.computercraft.api.peripheral.IPeripheral;
-
-import java.util.Map;
-
-/**
- * A wired network is composed of one of more {@link WiredNode}s, a set of connections between them, and a series
- * of peripherals.
- * <p>
- * Networks from a connected graph. This means there is some path between all nodes on the network. Further more, if
- * there is some path between two nodes then they must be on the same network. {@link WiredNetwork} will automatically
- * handle the merging and splitting of networks (and thus changing of available nodes and peripherals) as connections
- * change.
- * <p>
- * This does mean one can not rely on the network remaining consistent between subsequent operations. Consequently,
- * it is generally preferred to use the methods provided by {@link WiredNode}.
- *
- * @see WiredNode#getNetwork()
- */
-public interface WiredNetwork {
-    /**
-     * Create a connection between two nodes.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @param left  The first node to connect
-     * @param right The second node to connect
-     * @return {@code true} if a connection was created or {@code false} if the connection already exists.
-     * @throws IllegalStateException    If neither node is on the network.
-     * @throws IllegalArgumentException If {@code left} and {@code right} are equal.
-     * @see WiredNode#connectTo(WiredNode)
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
-     */
-    boolean connect(WiredNode left, WiredNode right);
-
-    /**
-     * Destroy a connection between this node and another.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @param left  The first node in the connection.
-     * @param right The second node in the connection.
-     * @return {@code true} if a connection was destroyed or {@code false} if no connection exists.
-     * @throws IllegalArgumentException If either node is not on the network.
-     * @throws IllegalArgumentException If {@code left} and {@code right} are equal.
-     * @see WiredNode#disconnectFrom(WiredNode)
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
-     */
-    boolean disconnect(WiredNode left, WiredNode right);
-
-    /**
-     * Sever all connections this node has, removing it from this network.
-     * <p>
-     * This should only be used on the server thread. You should only call this on nodes
-     * that your network element owns.
-     *
-     * @param node The node to remove
-     * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
-     * only element.
-     * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNode#remove()
-     */
-    boolean remove(WiredNode node);
-
-    /**
-     * Update the peripherals a node provides.
-     * <p>
-     * This should only be used on the server thread. You should only call this on nodes
-     * that your network element owns.
-     *
-     * @param node        The node to attach peripherals for.
-     * @param peripherals The new peripherals for this node.
-     * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNode#updatePeripherals(Map)
-     */
-    void updatePeripherals(WiredNode node, Map<String, IPeripheral> peripherals);
-}

projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNode.java

@@ -6,11 +6,12 @@ package dan200.computercraft.api.network.wired;
 
 import dan200.computercraft.api.network.PacketNetwork;
 import dan200.computercraft.api.peripheral.IPeripheral;
+import org.jetbrains.annotations.ApiStatus;
 
 import java.util.Map;
 
 /**
- * Wired nodes act as a layer between {@link WiredElement}s and {@link WiredNetwork}s.
+ * A single node on a wired network.
  * <p>
  * Firstly, a node acts as a packet network, capable of sending and receiving modem messages to connected nodes. These
  * methods may be safely used on any thread.
@@ -22,6 +23,7 @@ import java.util.Map;
  * Wired nodes also provide several convenience methods for interacting with a wired network. These should only ever
  * be used on the main server thread.
  */
+@ApiStatus.NonExtendable
 public interface WiredNode extends PacketNetwork {
     /**
      * The associated element for this network node.
@@ -30,16 +32,6 @@ public interface WiredNode extends PacketNetwork {
      */
     WiredElement getElement();
 
-    /**
-     * The network this node is currently connected to. Note that this may change
-     * after any network operation, so it should not be cached.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @return This node's network.
-     */
-    WiredNetwork getNetwork();
-
     /**
      * Create a connection from this node to another.
      * <p>
@@ -47,12 +39,9 @@ public interface WiredNode extends PacketNetwork {
      *
      * @param node The other node to connect to.
      * @return {@code true} if a connection was created or {@code false} if the connection already exists.
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
      * @see WiredNode#disconnectFrom(WiredNode)
      */
-    default boolean connectTo(WiredNode node) {
-        return getNetwork().connect(this, node);
-    }
+    boolean connectTo(WiredNode node);
 
     /**
      * Destroy a connection between this node and another.
@@ -61,13 +50,9 @@ public interface WiredNode extends PacketNetwork {
      *
      * @param node The other node to disconnect from.
      * @return {@code true} if a connection was destroyed or {@code false} if no connection exists.
-     * @throws IllegalArgumentException If {@code node} is not on the same network.
-     * @see WiredNetwork#disconnect(WiredNode, WiredNode)
      * @see WiredNode#connectTo(WiredNode)
      */
-    default boolean disconnectFrom(WiredNode node) {
-        return getNetwork().disconnect(this, node);
-    }
+    boolean disconnectFrom(WiredNode node);
 
     /**
      * Sever all connections this node has, removing it from this network.
@@ -78,11 +63,8 @@ public interface WiredNode extends PacketNetwork {
      * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
      * only element.
      * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNetwork#remove(WiredNode)
      */
-    default boolean remove() {
-        return getNetwork().remove(this);
-    }
+    boolean remove();
 
     /**
      * Mark this node's peripherals as having changed.
@@ -91,9 +73,6 @@ public interface WiredNode extends PacketNetwork {
      * that your network element owns.
      *
      * @param peripherals The new peripherals for this node.
-     * @see WiredNetwork#updatePeripherals(WiredNode, Map)
      */
-    default void updatePeripherals(Map<String, IPeripheral> peripherals) {
-        getNetwork().updatePeripherals(this, peripherals);
-    }
+    void updatePeripherals(Map<String, IPeripheral> peripherals);
 }

projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredSender.java

@@ -8,10 +8,12 @@ import dan200.computercraft.api.network.PacketSender;
 
 
 /**
- * An object on a {@link WiredNetwork} capable of sending packets.
+ * An object on a wired network capable of sending packets.
  * <p>
  * Unlike a regular {@link PacketSender}, this must be associated with the node you are attempting to
  * to send the packet from.
+ *
+ * @see WiredElement
  */
 public interface WiredSender extends PacketSender {
     /**

projects/common-api/src/main/java/dan200/computercraft/api/pocket/AbstractPocketUpgrade.java

@@ -4,8 +4,7 @@
 
 package dan200.computercraft.api.pocket;
 
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
 
@@ -15,27 +14,20 @@ import net.minecraft.world.item.ItemStack;
  * One does not have to use this, but it does provide a convenient template.
  */
 public abstract class AbstractPocketUpgrade implements IPocketUpgrade {
-    private final ResourceLocation id;
-    private final String adjective;
+    private final Component adjective;
     private final ItemStack stack;
 
-    protected AbstractPocketUpgrade(ResourceLocation id, String adjective, ItemStack stack) {
-        this.id = id;
+    protected AbstractPocketUpgrade(Component adjective, ItemStack stack) {
         this.adjective = adjective;
         this.stack = stack;
     }
 
-    protected AbstractPocketUpgrade(ResourceLocation id, ItemStack stack) {
-        this(id, UpgradeBase.getDefaultAdjective(id), stack);
+    protected AbstractPocketUpgrade(String adjective, ItemStack stack) {
+        this(Component.translatable(adjective), stack);
     }
 
     @Override
-    public final ResourceLocation getUpgradeID() {
-        return id;
-    }
-
-    @Override
-    public final String getUnlocalisedAdjective() {
+    public final Component getAdjective() {
         return adjective;
     }
 

projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketAccess.java

@@ -4,15 +4,12 @@
 
 package dan200.computercraft.api.pocket;
 
-import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.item.ItemStack;
 
 import javax.annotation.Nullable;
-import java.util.Map;
 
 /**
  * Wrapper class for pocket computers.
@@ -70,18 +67,19 @@ public interface IPocketAccess {
      * This is persisted between computer reboots and chunk loads.
      *
      * @return The upgrade's NBT.
-     * @see #updateUpgradeNBTData()
-     * @see UpgradeBase#getUpgradeItem(CompoundTag)
+     * @see #setUpgradeData(DataComponentPatch)
+     * @see UpgradeBase#getUpgradeItem(DataComponentPatch)
      * @see UpgradeBase#getUpgradeData(ItemStack)
      */
-    CompoundTag getUpgradeNBTData();
+    DataComponentPatch getUpgradeData();
 
     /**
-     * Mark the upgrade-specific NBT as dirty.
+     * Update the upgrade-specific data.
      *
-     * @see #getUpgradeNBTData()
+     * @param data The new upgrade data.
+     * @see #getUpgradeData()
      */
-    void updateUpgradeNBTData();
+    void setUpgradeData(DataComponentPatch data);
 
     /**
      * Remove the current peripheral and create a new one.
@@ -90,13 +88,4 @@ public interface IPocketAccess {
      * entity} changes.
      */
     void invalidatePeripheral();
-
-    /**
-     * Get a list of all upgrades for the pocket computer.
-     *
-     * @return A collection of all upgrade names.
-     * @deprecated This is a relic of a previous API, which no longer makes sense with newer versions of ComputerCraft.
-     */
-    @Deprecated(forRemoval = true)
-    Map<ResourceLocation, IPeripheral> getUpgrades();
 }

projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketUpgrade.java

@@ -4,8 +4,14 @@
 
 package dan200.computercraft.api.pocket;
 
+import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.ComputerCraftAPIService;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.Level;
 
 import javax.annotation.Nullable;
@@ -13,16 +19,54 @@ import javax.annotation.Nullable;
 /**
  * A peripheral which can be equipped to the back side of a pocket computer.
  * <p>
- * Pocket upgrades are defined in two stages. First, on creates a {@link IPocketUpgrade} subclass and corresponding
- * {@link PocketUpgradeSerialiser} instance, which are then registered in a Forge registry.
+ * Pocket upgrades are defined in two stages. First, one creates a {@link IPocketUpgrade} subclass and corresponding
+ * {@link UpgradeType} instance, which are then registered in a registry.
  * <p>
  * You then write a JSON file in your mod's {@literal data/} folder. This is then parsed when the world is loaded, and
- * the upgrade registered internally. See the documentation in {@link PocketUpgradeSerialiser} for details on this process
- * and where files should be located.
+ * the upgrade automatically registered. It is recommended this is done via
+ * <a href="../upgrades/UpgradeType.html#datagen">data generators</a>.
  *
- * @see PocketUpgradeSerialiser For how to register a pocket computer upgrade.
+ * <h2>Example</h2>
+ * {@snippet lang="java" :
+ * // We use Forge's DeferredRegister to register our upgrade type. Fabric mods may register their type directly.
+ * static final DeferredRegister<UpgradeType<? extends IPocketUpgrade>> POCKET_UPGRADES = DeferredRegister.create(IPocketUpgrade.typeRegistry(), "my_mod");
+ *
+ * // Register a new upgrade upgrade type called "my_upgrade".
+ * public static final RegistryObject<UpgradeType<MyUpgrade>> MY_UPGRADE =
+ *     POCKET_UPGRADES.register("my_upgrade", () -> UpgradeType.simple(new MyUpgrade()));
+ *
+ * // Then in your constructor
+ * POCKET_UPGRADES.register(bus);
+ * }
+ * <p>
+ * We can then define a new upgrade using JSON by placing the following in
+ * {@code data/<my_mod>/computercraft/pocket_upgrade/<my_upgrade_id>.json}.
+ * {@snippet lang="json" :
+ * {
+ *     "type": "my_mod:my_upgrade"
+ * }
+ * }
  */
 public interface IPocketUpgrade extends UpgradeBase {
+    ResourceKey<Registry<IPocketUpgrade>> REGISTRY = ResourceKey.createRegistryKey(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "pocket_upgrade"));
+
+    /**
+     * The registry key for pocket upgrade types.
+     *
+     * @return The registry key.
+     */
+    static ResourceKey<Registry<UpgradeType<? extends IPocketUpgrade>>> typeRegistry() {
+        return ComputerCraftAPIService.get().pocketUpgradeRegistryId();
+    }
+
+    /**
+     * Get the type of this upgrade.
+     *
+     * @return The type of this upgrade.
+     */
+    @Override
+    UpgradeType<? extends IPocketUpgrade> getType();
+
     /**
      * Creates a peripheral for the pocket computer.
      * <p>

projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeDataProvider.java

@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.pocket;
-
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import net.minecraft.data.DataGenerator;
-import net.minecraft.data.PackOutput;
-
-import java.util.function.Consumer;
-
-/**
- * A data provider to generate pocket computer upgrades.
- * <p>
- * This should be subclassed and registered to a {@link DataGenerator.PackGenerator}. Override the
- * {@link #addUpgrades(Consumer)} function, construct each upgrade, and pass them off to the provided consumer to
- * generate them.
- *
- * @see PocketUpgradeSerialiser
- */
-public abstract class PocketUpgradeDataProvider extends UpgradeDataProvider<IPocketUpgrade, PocketUpgradeSerialiser<?>> {
-    public PocketUpgradeDataProvider(PackOutput output) {
-        super(output, "Pocket Computer Upgrades", "computercraft/pocket_upgrades", PocketUpgradeSerialiser.registryId());
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeSerialiser.java

@@ -1,79 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.pocket;
-
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
-
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-/**
- * Reads a {@link IPocketUpgrade} from disk and reads/writes it to a network packet.
- * <p>
- * This follows the same format as {@link dan200.computercraft.api.turtle.TurtleUpgradeSerialiser} - consult the
- * documentation there for more information.
- *
- * @param <T> The type of pocket computer upgrade this is responsible for serialising.
- * @see IPocketUpgrade
- * @see PocketUpgradeDataProvider
- */
-public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends UpgradeSerialiser<T> {
-    /**
-     * The ID for the associated registry.
-     *
-     * @return The registry key.
-     */
-    static ResourceKey<Registry<PocketUpgradeSerialiser<?>>> registryId() {
-        return ComputerCraftAPIService.get().pocketUpgradeRegistryId();
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade. This is similar to a {@link SimpleCraftingRecipeSerializer},
-     * but for upgrades.
-     * <p>
-     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(BiFunction)} instead.
-     *
-     * @param factory Generate a new upgrade with a specific ID.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade
-     */
-    static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simple(Function<ResourceLocation, T> factory) {
-        final class Impl extends SimpleSerialiser<T> implements PocketUpgradeSerialiser<T> {
-            private Impl(Function<ResourceLocation, T> constructor) {
-                super(constructor);
-            }
-        }
-
-        return new Impl(factory);
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade whose crafting item can be specified.
-     *
-     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
-     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade.
-     * @see #simple(Function)  For upgrades whose crafting stack should not vary.
-     */
-    static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simpleWithCustomItem(BiFunction<ResourceLocation, ItemStack, T> factory) {
-        final class Impl extends SerialiserWithCraftingItem<T> implements PocketUpgradeSerialiser<T> {
-            private Impl(BiFunction<ResourceLocation, ItemStack, T> factory) {
-                super(factory);
-            }
-        }
-
-        return new Impl(factory);
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/turtle/AbstractTurtleUpgrade.java

@@ -4,8 +4,7 @@
 
 package dan200.computercraft.api.turtle;
 
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
 
@@ -15,34 +14,27 @@ import net.minecraft.world.item.ItemStack;
  * One does not have to use this, but it does provide a convenient template.
  */
 public abstract class AbstractTurtleUpgrade implements ITurtleUpgrade {
-    private final ResourceLocation id;
     private final TurtleUpgradeType type;
-    private final String adjective;
+    private final Component adjective;
     private final ItemStack stack;
 
-    protected AbstractTurtleUpgrade(ResourceLocation id, TurtleUpgradeType type, String adjective, ItemStack stack) {
-        this.id = id;
+    protected AbstractTurtleUpgrade(TurtleUpgradeType type, Component adjective, ItemStack stack) {
         this.type = type;
         this.adjective = adjective;
         this.stack = stack;
     }
 
-    protected AbstractTurtleUpgrade(ResourceLocation id, TurtleUpgradeType type, ItemStack stack) {
-        this(id, type, UpgradeBase.getDefaultAdjective(id), stack);
+    protected AbstractTurtleUpgrade(TurtleUpgradeType type, String adjective, ItemStack stack) {
+        this(type, Component.translatable(adjective), stack);
     }
 
     @Override
-    public final ResourceLocation getUpgradeID() {
-        return id;
-    }
-
-    @Override
-    public final String getUnlocalisedAdjective() {
+    public final Component getAdjective() {
         return adjective;
     }
 
     @Override
-    public final TurtleUpgradeType getType() {
+    public final TurtleUpgradeType getUpgradeType() {
         return type;
     }
 

projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleAccess.java

@@ -12,7 +12,7 @@ import dan200.computercraft.api.upgrades.UpgradeBase;
 import dan200.computercraft.api.upgrades.UpgradeData;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.Container;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
@@ -229,37 +229,22 @@ public interface ITurtleAccess {
      * @param side The side to get the upgrade from.
      * @return The upgrade on the specified side of the turtle, if there is one.
      * @see #getUpgradeWithData(TurtleSide)
-     * @see #setUpgradeWithData(TurtleSide, UpgradeData)
+     * @see #setUpgrade(TurtleSide, UpgradeData)
      */
     @Nullable
     ITurtleUpgrade getUpgrade(TurtleSide side);
 
     /**
-     * Returns the upgrade on the specified side of the turtle, along with its {@linkplain #getUpgradeNBTData(TurtleSide)
+     * Returns the upgrade on the specified side of the turtle, along with its {@linkplain #getUpgradeData(TurtleSide)
      * update data}.
      *
      * @param side The side to get the upgrade from.
      * @return The upgrade on the specified side of the turtle, along with its upgrade data, if there is one.
      * @see #getUpgradeWithData(TurtleSide)
-     * @see #setUpgradeWithData(TurtleSide, UpgradeData)
+     * @see #setUpgrade(TurtleSide, UpgradeData)
      */
-    default @Nullable UpgradeData<ITurtleUpgrade> getUpgradeWithData(TurtleSide side) {
-        var upgrade = getUpgrade(side);
-        return upgrade == null ? null : UpgradeData.of(upgrade, getUpgradeNBTData(side));
-    }
-
-    /**
-     * Set the upgrade for a given side, resetting peripherals and clearing upgrade specific data.
-     *
-     * @param side    The side to set the upgrade on.
-     * @param upgrade The upgrade to set, may be {@code null} to clear.
-     * @see #getUpgrade(TurtleSide)
-     * @deprecated Use {@link #setUpgradeWithData(TurtleSide, UpgradeData)}
-     */
-    @Deprecated
-    default void setUpgrade(TurtleSide side, @Nullable ITurtleUpgrade upgrade) {
-        setUpgradeWithData(side, upgrade == null ? null : UpgradeData.ofDefault(upgrade));
-    }
+    @Nullable
+    UpgradeData<ITurtleUpgrade> getUpgradeWithData(TurtleSide side);
 
     /**
      * Set the upgrade for a given side and its upgrade data.
@@ -268,7 +253,7 @@ public interface ITurtleAccess {
      * @param upgrade The upgrade to set, may be {@code null} to clear.
      * @see #getUpgradeWithData(TurtleSide)
      */
-    void setUpgradeWithData(TurtleSide side, @Nullable UpgradeData<ITurtleUpgrade> upgrade);
+    void setUpgrade(TurtleSide side, @Nullable UpgradeData<ITurtleUpgrade> upgrade);
 
     /**
      * Returns the peripheral created by the upgrade on the specified side of the turtle, if there is one.
@@ -282,23 +267,23 @@ public interface ITurtleAccess {
     /**
      * Get an upgrade-specific NBT compound, which can be used to store arbitrary data.
      * <p>
-     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You must
-     * call {@link #updateUpgradeNBTData(TurtleSide)} after modifying it.
+     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You can
+     * call {@link #setUpgrade(TurtleSide, UpgradeData)} to modify it.
      *
      * @param side The side to get the upgrade data for.
      * @return The upgrade-specific data.
-     * @see #updateUpgradeNBTData(TurtleSide)
-     * @see UpgradeBase#getUpgradeItem(CompoundTag)
+     * @see #setUpgradeData(TurtleSide, DataComponentPatch)
+     * @see UpgradeBase#getUpgradeItem(DataComponentPatch)
      * @see UpgradeBase#getUpgradeData(ItemStack)
      */
-    CompoundTag getUpgradeNBTData(TurtleSide side);
+    DataComponentPatch getUpgradeData(TurtleSide side);
 
     /**
-     * Mark the upgrade-specific data as dirty on a specific side. This is required for the data to be synced to the
-     * client and persisted.
+     * Update the upgrade-specific data.
      *
-     * @param side The side to mark dirty.
-     * @see #updateUpgradeNBTData(TurtleSide)
+     * @param side The side to set the upgrade data for.
+     * @param data The new upgrade data.
+     * @see #getUpgradeData(TurtleSide)
      */
-    void updateUpgradeNBTData(TurtleSide side);
+    void setUpgradeData(TurtleSide side, DataComponentPatch data);
 }

projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleUpgrade.java

@@ -4,10 +4,16 @@
 
 package dan200.computercraft.api.turtle;
 
+import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.ComputerCraftAPIService;
 import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.Registry;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
 
 import javax.annotation.Nullable;
 
@@ -16,22 +22,79 @@ import javax.annotation.Nullable;
  * peripheral.
  * <p>
  * Turtle upgrades are defined in two stages. First, one creates a {@link ITurtleUpgrade} subclass and corresponding
- * {@link TurtleUpgradeSerialiser} instance, which are then registered in a Forge registry.
+ * {@link UpgradeType} instance, which are then registered in a registry.
  * <p>
  * You then write a JSON file in your mod's {@literal data/} folder. This is then parsed when the world is loaded, and
- * the upgrade registered internally. See the documentation in {@link TurtleUpgradeSerialiser} for details on this process
- * and where files should be located.
+ * the upgrade automatically registered. It is recommended this is done via
+ * <a href="../upgrades/UpgradeType.html#datagen">data generators</a>.
  *
- * @see TurtleUpgradeSerialiser For how to register a turtle upgrade.
+ * <h2>Example</h2>
+ * {@snippet lang="java" :
+ * // We use Forge's DeferredRegister to register our upgrade type. Fabric mods may register their type directly.
+ * static final DeferredRegister<UpgradeType<? extends ITurtleUpgrade>> TURTLE_UPGRADES = DeferredRegister.create(ITurtleUpgrade.typeRegistry(), "my_mod");
+ *
+ * // Register a new upgrade type called "my_upgrade".
+ * public static final RegistryObject<UpgradeType<MyUpgrade>> MY_UPGRADE =
+ *     TURTLE_UPGRADES.register("my_upgrade", () -> UpgradeType.simple(MyUpgrade::new));
+ *
+ * // Then in your constructor
+ * TURTLE_UPGRADES.register(bus);
+ * }
+ * <p>
+ * We can then define a new upgrade using JSON by placing the following in
+ * {@code data/<my_mod>/computercraft/turtle_upgrade/<my_upgrade_id>.json}.
+ * <p>
+ * {@snippet lang="json" :
+ * {
+ *     "type": "my_mod:my_upgrade"
+ * }
+ * }
+ * <p>
+ * Finally, we need to register a model for our upgrade, see
+ * {@link dan200.computercraft.api.client.turtle.TurtleUpgradeModeller} for more information.
  */
 public interface ITurtleUpgrade extends UpgradeBase {
+    /**
+     * The registry in which turtle upgrades are stored.
+     */
+    ResourceKey<Registry<ITurtleUpgrade>> REGISTRY = ResourceKey.createRegistryKey(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "turtle_upgrade"));
+
+    /**
+     * Create a {@link ResourceKey} for a turtle upgrade given a {@link ResourceLocation}.
+     * <p>
+     * This should only be called from within data generation code. Do not hard code references to your upgrades!
+     *
+     * @param id The id of the turtle upgrade.
+     * @return The upgrade registry key.
+     */
+    static ResourceKey<ITurtleUpgrade> createKey(ResourceLocation id) {
+        return ResourceKey.create(REGISTRY, id);
+    }
+
+    /**
+     * The registry key for turtle upgrade types.
+     *
+     * @return The registry key.
+     */
+    static ResourceKey<Registry<UpgradeType<? extends ITurtleUpgrade>>> typeRegistry() {
+        return ComputerCraftAPIService.get().turtleUpgradeRegistryId();
+    }
+
+    /**
+     * Get the type of this upgrade.
+     *
+     * @return The type of this upgrade.
+     */
+    @Override
+    UpgradeType<? extends ITurtleUpgrade> getType();
+
     /**
      * Return whether this turtle adds a tool or a peripheral to the turtle.
      *
      * @return The type of upgrade this is.
      * @see TurtleUpgradeType for the differences between them.
      */
-    TurtleUpgradeType getType();
+    TurtleUpgradeType getUpgradeType();
 
     /**
      * Will only be called for peripheral upgrades. Creates a peripheral for a turtle being placed using this upgrade.
@@ -90,7 +153,7 @@ public interface ITurtleUpgrade extends UpgradeBase {
      * @param upgradeData Data that currently stored for this upgrade
      * @return Filtered version of this data.
      */
-    default CompoundTag getPersistedData(CompoundTag upgradeData) {
+    default DataComponentPatch getPersistedData(DataComponentPatch upgradeData) {
         return upgradeData;
     }
 }

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolBuilder.java

@@ -0,0 +1,157 @@
+// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.turtle;
+
+import dan200.computercraft.api.ComputerCraftTags;
+import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.impl.ComputerCraftAPIService;
+import dan200.computercraft.impl.upgrades.TurtleToolSpec;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.data.worldgen.BootstrapContext;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+
+import javax.annotation.Nullable;
+import java.util.Optional;
+
+/**
+ * A builder for custom turtle tool upgrades.
+ * <p>
+ * This can be used from your <a href="../upgrades/UpgradeType.html#datagen">data generator</a> code in order to
+ * register turtle tools for your mod's tools.
+ *
+ * <h2>Example:</h2>
+ * {@snippet lang = "java":
+ * import net.minecraft.data.worldgen.BootstrapContext;
+ * import net.minecraft.resources.ResourceLocation;
+ * import net.minecraft.world.item.Items;
+ *
+ * public void registerTool(BootstrapContext<ITurtleUpgrade> upgrades) {
+ *   TurtleToolBuilder.tool(ResourceLocation.fromNamespaceAndPath("my_mod", "wooden_pickaxe"), Items.WOODEN_PICKAXE).register(upgrades);
+ * }
+ *}
+ */
+public final class TurtleToolBuilder {
+    private final ResourceKey<ITurtleUpgrade> id;
+    private final Item item;
+    private Component adjective;
+    private float damageMultiplier = TurtleToolSpec.DEFAULT_DAMAGE_MULTIPLIER;
+    private @Nullable TagKey<Block> breakable;
+    private boolean allowEnchantments = false;
+    private TurtleToolDurability consumeDurability = TurtleToolDurability.NEVER;
+
+    private TurtleToolBuilder(ResourceKey<ITurtleUpgrade> id, Item item) {
+        this.id = id;
+        adjective = Component.translatable(UpgradeBase.getDefaultAdjective(id.location()));
+        this.item = item;
+    }
+
+    public static TurtleToolBuilder tool(ResourceLocation id, Item item) {
+        return new TurtleToolBuilder(ITurtleUpgrade.createKey(id), item);
+    }
+
+    public static TurtleToolBuilder tool(ResourceKey<ITurtleUpgrade> id, Item item) {
+        return new TurtleToolBuilder(id, item);
+    }
+
+    /**
+     * Get the id for this turtle tool.
+     *
+     * @return The upgrade id.
+     */
+    public ResourceKey<ITurtleUpgrade> id() {
+        return id;
+    }
+
+    /**
+     * Specify a custom adjective for this tool. By default this takes its adjective from the upgrade id.
+     *
+     * @param adjective The new adjective to use.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder adjective(Component adjective) {
+        this.adjective = adjective;
+        return this;
+    }
+
+    /**
+     * The amount of damage a swing of this tool will do. This is multiplied by {@link Attributes#ATTACK_DAMAGE} to
+     * get the final damage.
+     *
+     * @param damageMultiplier The damage multiplier.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder damageMultiplier(float damageMultiplier) {
+        this.damageMultiplier = damageMultiplier;
+        return this;
+    }
+
+    /**
+     * Indicate that this upgrade allows items which have been {@linkplain ItemStack#isEnchanted() enchanted} or have
+     * {@linkplain DataComponents#ATTRIBUTE_MODIFIERS custom attribute modifiers}.
+     *
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder allowEnchantments() {
+        allowEnchantments = true;
+        return this;
+    }
+
+    /**
+     * Set when the tool will consume durability.
+     *
+     * @param durability The durability predicate.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder consumeDurability(TurtleToolDurability durability) {
+        consumeDurability = durability;
+        return this;
+    }
+
+    /**
+     * Provide a list of breakable blocks. If not given, the tool can break all blocks. If given, only blocks
+     * in this tag, those in {@link ComputerCraftTags.Blocks#TURTLE_ALWAYS_BREAKABLE} and "insta-mine" ones can
+     * be broken.
+     *
+     * @param breakable The tag containing all blocks breakable by this item.
+     * @return The tool builder, for further use.
+     * @see ComputerCraftTags.Blocks
+     */
+    public TurtleToolBuilder breakable(TagKey<Block> breakable) {
+        this.breakable = breakable;
+        return this;
+    }
+
+    /**
+     * Build the turtle tool upgrade.
+     *
+     * @return The constructed upgrade.
+     */
+    public ITurtleUpgrade build() {
+        return ComputerCraftAPIService.get().createTurtleTool(new TurtleToolSpec(
+            adjective,
+            item,
+            damageMultiplier,
+            allowEnchantments,
+            consumeDurability,
+            Optional.ofNullable(breakable)
+        ));
+    }
+
+    /**
+     * Build this upgrade and register it for datagen.
+     *
+     * @param upgrades The registry this upgrade should be added to.
+     */
+    public void register(BootstrapContext<ITurtleUpgrade> upgrades) {
+        upgrades.register(id(), build());
+    }
+}

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolDurability.java

@@ -4,14 +4,14 @@
 
 package dan200.computercraft.api.turtle;
 
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.util.StringRepresentable;
-import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.item.ItemStack;
 
 /**
  * Indicates if an equipped turtle item will consume durability.
  *
- * @see TurtleUpgradeDataProvider.ToolBuilder#consumeDurability(TurtleToolDurability)
+ * @see TurtleToolBuilder#consumeDurability(TurtleToolDurability)
  */
 public enum TurtleToolDurability implements StringRepresentable {
     /**
@@ -21,7 +21,7 @@ public enum TurtleToolDurability implements StringRepresentable {
 
     /**
      * The equipped tool consumes durability if it is {@linkplain ItemStack#isEnchanted() enchanted} or has
-     * {@linkplain ItemStack#getAttributeModifiers(EquipmentSlot) custom attribute modifiers}.
+     * {@linkplain DataComponents#ATTRIBUTE_MODIFIERS custom attribute modifiers}.
      */
     WHEN_ENCHANTED("when_enchanted"),
 

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeDataProvider.java

@@ -1,168 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.turtle;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.ComputerCraftTags;
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import dan200.computercraft.impl.PlatformHelper;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.data.DataGenerator;
-import net.minecraft.data.PackOutput;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.tags.TagKey;
-import net.minecraft.world.entity.EquipmentSlot;
-import net.minecraft.world.entity.ai.attributes.Attributes;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.Block;
-
-import javax.annotation.Nullable;
-import java.util.function.Consumer;
-
-/**
- * A data provider to generate turtle upgrades.
- * <p>
- * This should be subclassed and registered to a {@link DataGenerator.PackGenerator}. Override the
- * {@link #addUpgrades(Consumer)} function, construct each upgrade, and pass them off to the provided consumer to
- * generate them.
- *
- * @see TurtleUpgradeSerialiser
- */
-public abstract class TurtleUpgradeDataProvider extends UpgradeDataProvider<ITurtleUpgrade, TurtleUpgradeSerialiser<?>> {
-    private static final ResourceLocation TOOL_ID = new ResourceLocation(ComputerCraftAPI.MOD_ID, "tool");
-
-    public TurtleUpgradeDataProvider(PackOutput output) {
-        super(output, "Turtle Upgrades", "computercraft/turtle_upgrades", TurtleUpgradeSerialiser.registryId());
-    }
-
-    /**
-     * Create a new turtle tool upgrade, such as a pickaxe or shovel.
-     *
-     * @param id   The ID of this tool.
-     * @param item The item used for tool actions. Note, this doesn't inherit all properties of the tool, you may need
-     *             to specify {@link ToolBuilder#damageMultiplier(float)} and {@link ToolBuilder#breakable(TagKey)}.
-     * @return A tool builder,
-     */
-    public final ToolBuilder tool(ResourceLocation id, Item item) {
-        return new ToolBuilder(id, existingSerialiser(TOOL_ID), item);
-    }
-
-    /**
-     * A builder for custom turtle tool upgrades.
-     *
-     * @see #tool(ResourceLocation, Item)
-     */
-    public static class ToolBuilder {
-        private final ResourceLocation id;
-        private final TurtleUpgradeSerialiser<?> serialiser;
-        private final Item toolItem;
-        private @Nullable String adjective;
-        private @Nullable Item craftingItem;
-        private @Nullable Float damageMultiplier = null;
-        private @Nullable TagKey<Block> breakable;
-        private boolean allowEnchantments = false;
-        private TurtleToolDurability consumeDurability = TurtleToolDurability.NEVER;
-
-        ToolBuilder(ResourceLocation id, TurtleUpgradeSerialiser<?> serialiser, Item toolItem) {
-            this.id = id;
-            this.serialiser = serialiser;
-            this.toolItem = toolItem;
-            craftingItem = null;
-        }
-
-        /**
-         * Specify a custom adjective for this tool. By default this takes its adjective from the tool item.
-         *
-         * @param adjective The new adjective to use.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder adjective(String adjective) {
-            this.adjective = adjective;
-            return this;
-        }
-
-        /**
-         * Specify a custom item which is used to craft this upgrade. By default this is the same as the provided tool
-         * item, but you may wish to override it.
-         *
-         * @param craftingItem The item used to craft this upgrade.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder craftingItem(Item craftingItem) {
-            this.craftingItem = craftingItem;
-            return this;
-        }
-
-        /**
-         * The amount of damage a swing of this tool will do. This is multiplied by {@link Attributes#ATTACK_DAMAGE} to
-         * get the final damage.
-         *
-         * @param damageMultiplier The damage multiplier.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder damageMultiplier(float damageMultiplier) {
-            this.damageMultiplier = damageMultiplier;
-            return this;
-        }
-
-        /**
-         * Indicate that this upgrade allows items which have been {@linkplain ItemStack#isEnchanted() enchanted} or have
-         * {@linkplain ItemStack#getAttributeModifiers(EquipmentSlot) custom attribute modifiers}.
-         *
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder allowEnchantments() {
-            allowEnchantments = true;
-            return this;
-        }
-
-        /**
-         * Set when the tool will consume durability.
-         *
-         * @param durability The durability predicate.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder consumeDurability(TurtleToolDurability durability) {
-            consumeDurability = durability;
-            return this;
-        }
-
-        /**
-         * Provide a list of breakable blocks. If not given, the tool can break all blocks. If given, only blocks
-         * in this tag, those in {@link ComputerCraftTags.Blocks#TURTLE_ALWAYS_BREAKABLE} and "insta-mine" ones can
-         * be broken.
-         *
-         * @param breakable The tag containing all blocks breakable by this item.
-         * @return The tool builder, for further use.
-         * @see ComputerCraftTags.Blocks
-         */
-        public ToolBuilder breakable(TagKey<Block> breakable) {
-            this.breakable = breakable;
-            return this;
-        }
-
-        /**
-         * Register this as an upgrade.
-         *
-         * @param add The callback given to {@link #addUpgrades(Consumer)}.
-         */
-        public void add(Consumer<Upgrade<TurtleUpgradeSerialiser<?>>> add) {
-            add.accept(new Upgrade<>(id, serialiser, s -> {
-                s.addProperty("item", PlatformHelper.get().getRegistryKey(Registries.ITEM, toolItem).toString());
-                if (adjective != null) s.addProperty("adjective", adjective);
-                if (craftingItem != null) {
-                    s.addProperty("craftItem", PlatformHelper.get().getRegistryKey(Registries.ITEM, craftingItem).toString());
-                }
-                if (damageMultiplier != null) s.addProperty("damageMultiplier", damageMultiplier);
-                if (breakable != null) s.addProperty("breakable", breakable.location().toString());
-                if (allowEnchantments) s.addProperty("allowEnchantments", true);
-                if (consumeDurability != TurtleToolDurability.NEVER) {
-                    s.addProperty("consumeDurability", consumeDurability.getSerializedName());
-                }
-            }));
-        }
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeSerialiser.java

@@ -1,114 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.turtle;
-
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
-
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-/**
- * Reads a {@link ITurtleUpgrade} from disk and reads/writes it to a network packet.
- * <p>
- * These should be registered in a {@link Registry} while the game is loading, much like {@link RecipeSerializer}s.
- * <p>
- * If your turtle upgrade doesn't have any associated configurable parameters (like most upgrades), you can use
- * {@link #simple(Function)} or {@link #simpleWithCustomItem(BiFunction)} to create a basic upgrade serialiser.
- *
- * <h2>Example (Forge)</h2>
- * <pre>{@code
- * static final DeferredRegister<TurtleUpgradeSerialiser<?>> SERIALISERS = DeferredRegister.create( TurtleUpgradeSerialiser.TYPE, "my_mod" );
- *
- * // Register a new upgrade serialiser called "my_upgrade".
- * public static final RegistryObject<TurtleUpgradeSerialiser<MyUpgrade>> MY_UPGRADE =
- *     SERIALISERS.register( "my_upgrade", () -> TurtleUpgradeSerialiser.simple( MyUpgrade::new ) );
- *
- * // Then in your constructor
- * SERIALISERS.register( bus );
- * }</pre>
- * <p>
- * We can then define a new upgrade using JSON by placing the following in
- * {@literal data/<my_mod>/computercraft/turtle_upgrades/<my_upgrade_id>.json}}.
- *
- * <pre>{@code
- * {
- *     "type": my_mod:my_upgrade",
- * }
- * }</pre>
- * <p>
- * Finally, we need to register a model for our upgrade. This is done with
- * {@link dan200.computercraft.api.client.ComputerCraftAPIClient#registerTurtleUpgradeModeller}:
- *
- * <pre>{@code
- * // Register our model inside FMLClientSetupEvent
- * ComputerCraftAPIClient.registerTurtleUpgradeModeller(MY_UPGRADE.get(), TurtleUpgradeModeller.flatItem())
- * }</pre>
- * <p>
- * {@link TurtleUpgradeDataProvider} provides a data provider to aid with generating these JSON files.
- *
- * @param <T> The type of turtle upgrade this is responsible for serialising.
- * @see ITurtleUpgrade
- * @see TurtleUpgradeDataProvider
- * @see dan200.computercraft.api.client.turtle.TurtleUpgradeModeller
- */
-public interface TurtleUpgradeSerialiser<T extends ITurtleUpgrade> extends UpgradeSerialiser<T> {
-    /**
-     * The ID for the associated registry.
-     *
-     * @return The registry key.
-     */
-    static ResourceKey<Registry<TurtleUpgradeSerialiser<?>>> registryId() {
-        return ComputerCraftAPIService.get().turtleUpgradeRegistryId();
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade. This is similar to a {@link SimpleCraftingRecipeSerializer},
-     * but for upgrades.
-     * <p>
-     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(BiFunction)} instead.
-     *
-     * @param factory Generate a new upgrade with a specific ID.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade
-     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simple(Function<ResourceLocation, T> factory) {
-        final class Impl extends SimpleSerialiser<T> implements TurtleUpgradeSerialiser<T> {
-            private Impl(Function<ResourceLocation, T> constructor) {
-                super(constructor);
-            }
-        }
-
-        return new Impl(factory);
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade whose crafting item can be specified.
-     *
-     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
-     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade.
-     * @see #simple(Function)  For upgrades whose crafting stack should not vary.
-     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simpleWithCustomItem(BiFunction<ResourceLocation, ItemStack, T> factory) {
-        final class Impl extends SerialiserWithCraftingItem<T> implements TurtleUpgradeSerialiser<T> {
-            private Impl(BiFunction<ResourceLocation, ItemStack, T> factory) {
-                super(factory);
-            }
-        }
-
-        return new Impl(factory);
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeBase.java

@@ -9,37 +9,34 @@ import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.impl.PlatformHelper;
 import net.minecraft.Util;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;
 
-import java.util.Objects;
-
 /**
  * Common functionality between {@link ITurtleUpgrade} and {@link IPocketUpgrade}.
  */
 public interface UpgradeBase {
     /**
-     * Gets a unique identifier representing this type of turtle upgrade. eg: "computercraft:wireless_modem"
-     * or "my_mod:my_upgrade".
-     * <p>
-     * You should use a unique resource domain to ensure this upgrade is uniquely identified.
-     * The upgrade will fail registration if an already used ID is specified.
+     * Get the type of this upgrade.
      *
-     * @return The unique ID for this upgrade.
+     * @return The type of this upgrade.
      */
-    ResourceLocation getUpgradeID();
+    UpgradeType<?> getType();
 
     /**
-     * Return an unlocalised string to describe this type of computer in item names.
+     * A description of this upgrade for use in item names.
+     * <p>
+     * This should typically be a {@linkplain Component#translatable(String) translation key}, rather than a hard coded
+     * string.
      * <p>
      * Examples of built-in adjectives are "Wireless", "Mining" and "Crafty".
      *
-     * @return The localisation key for this upgrade's adjective.
+     * @return The text component for this upgrade's adjective.
      */
-    String getUnlocalisedAdjective();
+    Component getAdjective();
 
     /**
      * Return an item stack representing the type of item that a computer must be crafted
@@ -57,8 +54,8 @@ public interface UpgradeBase {
     /**
      * Returns the item stack representing a currently equipped turtle upgrade.
      * <p>
-     * While upgrades can store upgrade data ({@link ITurtleAccess#getUpgradeNBTData(TurtleSide)} and
-     * {@link IPocketAccess#getUpgradeNBTData()}}, by default this data is discarded when an upgrade is unequipped,
+     * While upgrades can store upgrade data ({@link ITurtleAccess#getUpgradeData(TurtleSide)} and
+     * {@link IPocketAccess#getUpgradeData()}}, by default this data is discarded when an upgrade is unequipped,
      * and the original item stack is returned.
      * <p>
      * By overriding this method, you can create a new {@link ItemStack} which contains enough data to
@@ -70,24 +67,24 @@ public interface UpgradeBase {
      * @param upgradeData The current upgrade data. This should <strong>NOT</strong> be mutated.
      * @return The item stack returned when unequipping.
      */
-    default ItemStack getUpgradeItem(CompoundTag upgradeData) {
+    default ItemStack getUpgradeItem(DataComponentPatch upgradeData) {
         return getCraftingItem();
     }
 
     /**
      * Extract upgrade data from an {@link ItemStack}.
      * <p>
-     * This upgrade data will be available with {@link ITurtleAccess#getUpgradeNBTData(TurtleSide)} or
-     * {@link IPocketAccess#getUpgradeNBTData()}.
+     * This upgrade data will be available with {@link ITurtleAccess#getUpgradeData(TurtleSide)} or
+     * {@link IPocketAccess#getUpgradeData()}.
      * <p>
-     * This should be an inverse to {@link #getUpgradeItem(CompoundTag)}.
+     * This should be an inverse to {@link #getUpgradeItem(DataComponentPatch)}.
      *
      * @param stack The stack that was equipped by the turtle or pocket computer. This will have the same item as
      *              {@link #getCraftingItem()}.
      * @return The upgrade data that should be set on the turtle or pocket computer.
      */
-    default CompoundTag getUpgradeData(ItemStack stack) {
-        return new CompoundTag();
+    default DataComponentPatch getUpgradeData(ItemStack stack) {
+        return DataComponentPatch.EMPTY;
     }
 
     /**
@@ -97,26 +94,15 @@ public interface UpgradeBase {
      * the original stack. In order to prevent people losing items with enchantments (or
      * repairing items with non-0 damage), we impose additional checks on the item.
      * <p>
-     * The default check requires that any non-capability NBT is exactly the same as the
-     * crafting item, but this may be relaxed for your upgrade.
-     * <p>
-     * This is based on {@code net.minecraftforge.common.crafting.StrictNBTIngredient}'s check.
+     * The default check requires that any NBT is exactly the same as the crafting item,
+     * but this may be relaxed for your upgrade.
      *
      * @param stack The stack to check. This is guaranteed to be non-empty and have the same item as
      *              {@link #getCraftingItem()}.
      * @return If this stack may be used to equip this upgrade.
      */
     default boolean isItemSuitable(ItemStack stack) {
-        var crafting = getCraftingItem();
-
-        // A more expanded form of ItemStack.areShareTagsEqual, but allowing an empty tag to be equal to a
-        // null one.
-        var shareTag = PlatformHelper.get().getShareTag(stack);
-        var craftingShareTag = PlatformHelper.get().getShareTag(crafting);
-        if (shareTag == craftingShareTag) return true;
-        if (shareTag == null) return Objects.requireNonNull(craftingShareTag).isEmpty();
-        if (craftingShareTag == null) return shareTag.isEmpty();
-        return shareTag.equals(craftingShareTag);
+        return ItemStack.isSameItemSameComponents(getCraftingItem(), stack);
     }
 
     /**
@@ -125,7 +111,7 @@ public interface UpgradeBase {
      *
      * @param id The upgrade ID.
      * @return The  generated adjective.
-     * @see #getUnlocalisedAdjective()
+     * @see #getAdjective()
      */
     static String getDefaultAdjective(ResourceLocation id) {
         return Util.makeDescriptionId("upgrade", id) + ".adjective";

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeData.java

@@ -6,60 +6,57 @@ package dan200.computercraft.api.upgrades;
 
 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.Holder;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.Contract;
-
-import javax.annotation.Nullable;
 
 /**
  * An upgrade (i.e. a {@link ITurtleUpgrade}) and its current upgrade data.
- * <p>
- * <strong>IMPORTANT:</strong> The {@link #data()} in an upgrade data is often a reference to the original upgrade data.
- * Be careful to take a {@linkplain #copy() defensive copy} if you plan to use the data in this upgrade.
  *
- * @param upgrade The current upgrade.
- * @param data    The upgrade's data.
- * @param <T>     The type of upgrade, either {@link ITurtleUpgrade} or {@link IPocketUpgrade}.
+ * @param holder The current upgrade holder.
+ * @param data   The upgrade's data.
+ * @param <T>    The type of upgrade, either {@link ITurtleUpgrade} or {@link IPocketUpgrade}.
  */
-public record UpgradeData<T extends UpgradeBase>(T upgrade, CompoundTag data) {
+public record UpgradeData<T extends UpgradeBase>(Holder.Reference<T> holder, DataComponentPatch data) {
     /**
      * A utility method to construct a new {@link UpgradeData} instance.
      *
-     * @param upgrade An upgrade.
-     * @param data    The upgrade's data.
-     * @param <T>     The type of upgrade.
+     * @param holder An upgrade.
+     * @param data   The upgrade's data.
+     * @param <T>    The type of upgrade.
      * @return The new {@link UpgradeData} instance.
      */
-    public static <T extends UpgradeBase> UpgradeData<T> of(T upgrade, CompoundTag data) {
-        return new UpgradeData<>(upgrade, data);
+    public static <T extends UpgradeBase> UpgradeData<T> of(Holder.Reference<T> holder, DataComponentPatch data) {
+        return new UpgradeData<>(holder, data);
     }
 
     /**
      * Create an {@link UpgradeData} containing the default {@linkplain #data() data} for an upgrade.
      *
-     * @param upgrade The upgrade instance.
-     * @param <T>     The type of upgrade.
+     * @param holder The upgrade instance.
+     * @param <T>    The type of upgrade.
      * @return The default upgrade data.
      */
-    public static <T extends UpgradeBase> UpgradeData<T> ofDefault(T upgrade) {
-        return of(upgrade, upgrade.getUpgradeData(upgrade.getCraftingItem()));
+    public static <T extends UpgradeBase> UpgradeData<T> ofDefault(Holder.Reference<T> holder) {
+        var upgrade = holder.value();
+        return of(holder, upgrade.getUpgradeData(upgrade.getCraftingItem()));
+    }
+
+    public UpgradeData {
+        if (!holder.isBound()) throw new IllegalArgumentException("Holder is not bound");
     }
 
     /**
-     * Take a copy of a (possibly {@code null}) {@link UpgradeData} instance.
+     * Get the current upgrade.
      *
-     * @param upgrade The copied upgrade data.
-     * @param <T>     The type of upgrade.
-     * @return The newly created upgrade data.
+     * @return The current upgrade.
      */
-    @Contract("!null -> !null; null -> null")
-    public static <T extends UpgradeBase> @Nullable UpgradeData<T> copyOf(@Nullable UpgradeData<T> upgrade) {
-        return upgrade == null ? null : upgrade.copy();
+    public T upgrade() {
+        return holder().value();
     }
 
     /**
-     * Get the {@linkplain UpgradeBase#getUpgradeItem(CompoundTag) upgrade item} for this upgrade.
+     * Get the {@linkplain UpgradeBase#getUpgradeItem(DataComponentPatch) upgrade item} for this upgrade.
      * <p>
      * This returns a defensive copy of the item, to prevent accidental mutation of the upgrade data or original
      * {@linkplain UpgradeBase#getCraftingItem() upgrade stack}.
@@ -67,16 +64,6 @@ public record UpgradeData<T extends UpgradeBase>(T upgrade, CompoundTag data) {
      * @return This upgrade's item.
      */
     public ItemStack getUpgradeItem() {
-        return upgrade.getUpgradeItem(data).copy();
-    }
-
-    /**
-     * Take a copy of this {@link UpgradeData}. This returns a new instance with the same upgrade and a fresh copy of
-     * the upgrade data.
-     *
-     * @return A copy of the current instance.
-     */
-    public UpgradeData<T> copy() {
-        return new UpgradeData<>(upgrade(), data().copy());
+        return upgrade().getUpgradeItem(data).copy();
     }
 }

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeDataProvider.java

@@ -1,179 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.upgrades;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParseException;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.impl.PlatformHelper;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.Util;
-import net.minecraft.core.Registry;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.data.CachedOutput;
-import net.minecraft.data.DataProvider;
-import net.minecraft.data.PackOutput;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
-
-import javax.annotation.Nullable;
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-/**
- * A data generator/provider for turtle and pocket computer upgrades. This should not be extended directly, instead see
- * the other subclasses.
- *
- * @param <T> The base class of upgrades.
- * @param <R> The upgrade serialiser to register for.
- */
-public abstract class UpgradeDataProvider<T extends UpgradeBase, R extends UpgradeSerialiser<? extends T>> implements DataProvider {
-    private final PackOutput output;
-    private final String name;
-    private final String folder;
-    private final ResourceKey<Registry<R>> registry;
-
-    private @Nullable List<T> upgrades;
-
-    protected UpgradeDataProvider(PackOutput output, String name, String folder, ResourceKey<Registry<R>> registry) {
-        this.output = output;
-        this.name = name;
-        this.folder = folder;
-        this.registry = registry;
-    }
-
-    /**
-     * Register an upgrade using a "simple" serialiser (e.g. {@link TurtleUpgradeSerialiser#simple(Function)}).
-     *
-     * @param id         The ID of the upgrade to create.
-     * @param serialiser The simple serialiser.
-     * @return The constructed upgrade, ready to be passed off to {@link #addUpgrades(Consumer)}'s consumer.
-     */
-    public final Upgrade<R> simple(ResourceLocation id, R serialiser) {
-        if (!(serialiser instanceof SimpleSerialiser)) {
-            throw new IllegalStateException(serialiser + " must be a simple() seriaiser.");
-        }
-
-        return new Upgrade<>(id, serialiser, s -> {
-        });
-    }
-
-    /**
-     * Register an upgrade using a "simple" serialiser (e.g. {@link TurtleUpgradeSerialiser#simple(Function)}).
-     *
-     * @param id         The ID of the upgrade to create.
-     * @param serialiser The simple serialiser.
-     * @param item       The crafting upgrade for this item.
-     * @return The constructed upgrade, ready to be passed off to {@link #addUpgrades(Consumer)}'s consumer.
-     */
-    public final Upgrade<R> simpleWithCustomItem(ResourceLocation id, R serialiser, Item item) {
-        if (!(serialiser instanceof SerialiserWithCraftingItem)) {
-            throw new IllegalStateException(serialiser + " must be a simpleWithCustomItem() serialiser.");
-        }
-
-        return new Upgrade<>(id, serialiser, s ->
-            s.addProperty("item", PlatformHelper.get().getRegistryKey(Registries.ITEM, item).toString())
-        );
-    }
-
-    /**
-     * Add all turtle or pocket computer upgrades.
-     * <p>
-     * <strong>Example usage:</strong>
-     * <pre>{@code
-     * protected void addUpgrades(Consumer<Upgrade<TurtleUpgradeSerialiser<?>>> addUpgrade) {
-     *     simple(new ResourceLocation("mymod", "speaker"), SPEAKER_SERIALISER.get()).add(addUpgrade);
-     * }
-     * }</pre>
-     *
-     * @param addUpgrade A callback used to register an upgrade.
-     */
-    protected abstract void addUpgrades(Consumer<Upgrade<R>> addUpgrade);
-
-    @Override
-    public CompletableFuture<?> run(CachedOutput cache) {
-        var base = output.getOutputFolder().resolve("data");
-
-        Set<ResourceLocation> seen = new HashSet<>();
-        List<T> upgrades = new ArrayList<>();
-        List<CompletableFuture<?>> futures = new ArrayList<>();
-        addUpgrades(upgrade -> {
-            if (!seen.add(upgrade.id())) throw new IllegalStateException("Duplicate upgrade " + upgrade.id());
-
-            var json = new JsonObject();
-            json.addProperty("type", PlatformHelper.get().getRegistryKey(registry, upgrade.serialiser()).toString());
-            upgrade.serialise().accept(json);
-
-            futures.add(DataProvider.saveStable(cache, json, base.resolve(upgrade.id().getNamespace() + "/" + folder + "/" + upgrade.id().getPath() + ".json")));
-
-            try {
-                var result = upgrade.serialiser().fromJson(upgrade.id(), json);
-                upgrades.add(result);
-            } catch (IllegalArgumentException | JsonParseException e) {
-                LOGGER.error("Failed to parse {} {}", name, upgrade.id(), e);
-            }
-        });
-
-        this.upgrades = Collections.unmodifiableList(upgrades);
-        return Util.sequenceFailFast(futures);
-    }
-
-    @Override
-    public final String getName() {
-        return name;
-    }
-
-    public final R existingSerialiser(ResourceLocation id) {
-        var result = PlatformHelper.get().getRegistryObject(registry, id);
-        if (result == null) throw new IllegalArgumentException("No such serialiser " + registry);
-        return result;
-    }
-
-    public List<T> getGeneratedUpgrades() {
-        if (upgrades == null) throw new IllegalStateException("Upgrades have not been generated yet");
-        return upgrades;
-    }
-
-    /**
-     * A constructed upgrade instance, produced {@link #addUpgrades(Consumer)}.
-     *
-     * @param id         The ID for this upgrade.
-     * @param serialiser The serialiser which reads and writes this upgrade.
-     * @param serialise  Augment the generated JSON with additional fields.
-     * @param <R>        The type of upgrade serialiser.
-     */
-    public record Upgrade<R extends UpgradeSerialiser<?>>(
-        ResourceLocation id, R serialiser, Consumer<JsonObject> serialise
-    ) {
-        /**
-         * Convenience method for registering an upgrade.
-         *
-         * @param add The callback given to {@link #addUpgrades(Consumer)}
-         */
-        public void add(Consumer<Upgrade<R>> add) {
-            add.accept(this);
-        }
-
-        /**
-         * Return a new {@link Upgrade} which requires the given mod to be present.
-         * <p>
-         * This uses mod-loader-specific hooks (Forge's crafting conditions and Fabric's resource conditions). If using
-         * this in a multi-loader setup, you must generate resources separately for the two loaders.
-         *
-         * @param modId The id of the mod.
-         * @return A new upgrade instance.
-         */
-        public Upgrade<R> requireMod(String modId) {
-            return new Upgrade<>(id, serialiser, json -> {
-                PlatformHelper.get().addRequiredModCondition(json, modId);
-                serialise.accept(json);
-            });
-        }
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeSerialiser.java

@@ -1,52 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.upgrades;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.pocket.PocketUpgradeSerialiser;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.resources.ResourceLocation;
-
-
-/**
- * Base interface for upgrade serialisers. This should generally not be implemented directly, instead implementing one
- * of {@link TurtleUpgradeSerialiser} or {@link PocketUpgradeSerialiser}.
- * <p>
- * However, it may sometimes be useful to implement this if you have some shared logic between upgrade types.
- *
- * @param <T> The upgrade that this class can serialise and deserialise.
- * @see TurtleUpgradeSerialiser
- * @see PocketUpgradeSerialiser
- */
-public interface UpgradeSerialiser<T extends UpgradeBase> {
-    /**
-     * Read this upgrade from a JSON file in a datapack.
-     *
-     * @param id     The ID of this upgrade.
-     * @param object The JSON object to load this upgrade from.
-     * @return The constructed upgrade, with a {@link UpgradeBase#getUpgradeID()} equal to {@code id}.
-     * @see net.minecraft.util.GsonHelper For additional JSON helper methods.
-     */
-    T fromJson(ResourceLocation id, JsonObject object);
-
-    /**
-     * Read this upgrade from a network packet, sent from the server.
-     *
-     * @param id     The ID of this upgrade.
-     * @param buffer The buffer object to read this upgrade from.
-     * @return The constructed upgrade, with a {@link UpgradeBase#getUpgradeID()} equal to {@code id}.
-     */
-    T fromNetwork(ResourceLocation id, FriendlyByteBuf buffer);
-
-    /**
-     * Write this upgrade to a network packet, to be sent to the client.
-     *
-     * @param buffer  The buffer object to write this upgrade to
-     * @param upgrade The upgrade to write.
-     */
-    void toNetwork(FriendlyByteBuf buffer, T upgrade);
-
-}

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeType.java

@@ -0,0 +1,115 @@
+// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.upgrades;
+
+import com.mojang.serialization.MapCodec;
+import dan200.computercraft.api.pocket.IPocketUpgrade;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import dan200.computercraft.impl.upgrades.UpgradeTypeImpl;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.data.registries.RegistryPatchGenerator;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.level.storage.loot.functions.LootItemFunction;
+
+import java.util.function.Function;
+
+/**
+ * The type of a {@linkplain ITurtleUpgrade turtle} or {@linkplain IPocketUpgrade pocket} upgrade.
+ * <p>
+ * Turtle and pocket computer upgrades are registered using Minecraft's dynamic registry system. As a result, they
+ * follow a similar design to other dynamic content, such as {@linkplain Recipe recipes} or {@link LootItemFunction
+ * loot functions}.
+ * <p>
+ * First, one adds a new class implementing {@link ITurtleUpgrade} or {@link IPocketUpgrade}). This is responsible for
+ * handling all the logic of your upgrade.
+ * <p>
+ * However, the upgrades are not registered directly. Instead, each upgrade class should have a corresponding
+ * {@link UpgradeType}, which is responsible for loading the upgrade from a datapack. The upgrade type should then be
+ * registered in its appropriate registry ({@link ITurtleUpgrade#typeRegistry()},
+ * {@link IPocketUpgrade#typeRegistry()}).
+ * <p>
+ * In order to register the actual upgrade, a JSON file referencing your upgrade type should be added to a datapack. It
+ * is recommended to do this via the data generators.
+ *
+ * <h2 id="datagen">Data Generation</h2>
+ * As turtle and pocket upgrades are just loaded using vanilla's dynamic loaders, one may use the same data generation
+ * tools as you would for any other dynamic registry.
+ * <p>
+ * This can typically be done by extending vanilla's built-in registries using {@link RegistryPatchGenerator}, and then
+ * writing out the new registries using {@code net.fabricmc.fabric.api.datagen.v1.provider.FabricDynamicRegistryProvider}
+ * on Fabric or {@code net.neoforged.neoforge.common.data.DatapackBuiltinEntriesProvider} on Forge.
+ * <p>
+ * {@snippet lang="java" :
+ * import dan200.computercraft.api.turtle.ITurtleUpgrade;
+ * import net.minecraft.Util;
+ * import net.minecraft.core.HolderLookup;
+ * import net.minecraft.core.RegistrySetBuilder;
+ * import net.minecraft.data.DataGenerator;
+ * import net.neoforged.neoforge.common.data.DatapackBuiltinEntriesProvider;
+ *
+ * import java.util.concurrent.CompletableFuture;
+ *
+ * public void generate(DataGenerator.PackGenerator output, CompletableFuture<HolderLookup.Provider> registries) {
+ *     var newRegistries = RegistryPatchGenerator.createLookup(registries, Util.make(new RegistrySetBuilder(), builder -> {
+ *         builder.add(ITurtleUpgrade.REGISTRY, upgrades -> {
+ *             upgrades.register(ITurtleUpgrade.createKey(ResourceLocation.fromNamespaceAndPath("my_mod", "my_upgrade")), new MyUpgrade());
+ *         });
+ *     }));
+ *     output.addProvider(o -> new DatapackBuiltinEntriesProvider(o, newRegistries, Set.of("my_mod")));
+ * }
+ * }
+ *
+ * @param <T> The upgrade subclass that this upgrade type represents.
+ * @see ITurtleUpgrade
+ * @see IPocketUpgrade
+ */
+public interface UpgradeType<T extends UpgradeBase> {
+    /**
+     * The codec to read and write this upgrade from a datapack.
+     *
+     * @return The codec for this upgrade.
+     */
+    MapCodec<T> codec();
+
+    /**
+     * Create a new upgrade type.
+     *
+     * @param codec The codec
+     * @param <T>   The type of the generated upgrade.
+     * @return The newly created upgrade type.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> create(MapCodec<T> codec) {
+        return new UpgradeTypeImpl<>(codec);
+    }
+
+    /**
+     * Create an upgrade type for an upgrade that takes no arguments.
+     * <p>
+     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(Function)} instead.
+     *
+     * @param instance Generate a new upgrade with a specific ID.
+     * @param <T>      The type of the generated upgrade.
+     * @return A new upgrade type.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> simple(T instance) {
+        return create(MapCodec.unit(instance));
+    }
+
+    /**
+     * Create an upgrade type for a simple upgrade whose crafting item can be specified.
+     *
+     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
+     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
+     * @param <T>     The type of the generated upgrade.
+     * @return A new upgrade type.
+     * @see #simple(UpgradeBase)  For upgrades whose crafting stack should not vary.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> simpleWithCustomItem(Function<ItemStack, T> factory) {
+        return create(BuiltInRegistries.ITEM.byNameCodec()
+            .xmap(x -> factory.apply(new ItemStack(x)), x -> x.getCraftingItem().getItem())
+            .fieldOf("item"));
+    }
+}

projects/common-api/src/main/java/dan200/computercraft/impl/ComputerCraftAPIService.java

@@ -4,6 +4,7 @@
 
 package dan200.computercraft.impl;
 
+import com.mojang.serialization.Codec;
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.detail.BlockReference;
 import dan200.computercraft.api.detail.DetailRegistry;
@@ -15,10 +16,12 @@ import dan200.computercraft.api.media.MediaProvider;
 import dan200.computercraft.api.network.PacketNetwork;
 import dan200.computercraft.api.network.wired.WiredElement;
 import dan200.computercraft.api.network.wired.WiredNode;
-import dan200.computercraft.api.pocket.PocketUpgradeSerialiser;
+import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.redstone.BundledRedstoneProvider;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleRefuelHandler;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.upgrades.TurtleToolSpec;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.Registry;
@@ -67,9 +70,15 @@ public interface ComputerCraftAPIService {
 
     void registerRefuelHandler(TurtleRefuelHandler handler);
 
-    ResourceKey<Registry<TurtleUpgradeSerialiser<?>>> turtleUpgradeRegistryId();
+    ResourceKey<Registry<UpgradeType<? extends ITurtleUpgrade>>> turtleUpgradeRegistryId();
 
-    ResourceKey<Registry<PocketUpgradeSerialiser<?>>> pocketUpgradeRegistryId();
+    Codec<ITurtleUpgrade> turtleUpgradeCodec();
+
+    ResourceKey<Registry<UpgradeType<? extends IPocketUpgrade>>> pocketUpgradeRegistryId();
+
+    ITurtleUpgrade createTurtleTool(TurtleToolSpec spec);
+
+    Codec<IPocketUpgrade> pocketUpgradeCodec();
 
     DetailRegistry<ItemStack> getItemStackDetailRegistry();
 

projects/common-api/src/main/java/dan200/computercraft/impl/PlatformHelper.java

@@ -1,92 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.impl;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import net.minecraft.core.Registry;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.ApiStatus;
-
-import javax.annotation.Nullable;
-
-/**
- * Abstraction layer for Forge and Fabric. See implementations for more details.
- * <p>
- * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
- */
-@ApiStatus.Internal
-public interface PlatformHelper {
-    /**
-     * Get the current {@link PlatformHelper} instance.
-     *
-     * @return The current instance.
-     */
-    static PlatformHelper get() {
-        var instance = Instance.INSTANCE;
-        return instance == null ? Services.raise(PlatformHelper.class, Instance.ERROR) : instance;
-    }
-
-    /**
-     * Get the unique ID for a registered object.
-     *
-     * @param registry The registry to look up this object in.
-     * @param object   The object to look up.
-     * @param <T>      The type of object the registry stores.
-     * @return The registered object's ID.
-     * @throws IllegalArgumentException If the registry or object are not registered.
-     */
-    <T> ResourceLocation getRegistryKey(ResourceKey<Registry<T>> registry, T object);
-
-    /**
-     * Look up an ID in a registry, returning the registered object.
-     *
-     * @param registry The registry to look up this object in.
-     * @param id       The ID to look up.
-     * @param <T>      The type of object the registry stores.
-     * @return The resolved registry object.
-     * @throws IllegalArgumentException If the registry or object are not registered.
-     */
-    <T> T getRegistryObject(ResourceKey<Registry<T>> registry, ResourceLocation id);
-
-    /**
-     * Get the subset of an {@link ItemStack}'s {@linkplain ItemStack#getTag() tag} which is synced to the client.
-     *
-     * @param item The stack.
-     * @return The item's tag.
-     */
-    @Nullable
-    default CompoundTag getShareTag(ItemStack item) {
-        return item.getTag();
-    }
-
-    /**
-     * Add a resource condition which requires a mod to be loaded. This should be used by data providers such as
-     * {@link UpgradeDataProvider}.
-     *
-     * @param object The JSON object we're generating.
-     * @param modId  The mod ID that we require.
-     */
-    void addRequiredModCondition(JsonObject object, String modId);
-
-    final class Instance {
-        static final @Nullable PlatformHelper INSTANCE;
-        static final @Nullable Throwable ERROR;
-
-        static {
-            // We don't want class initialisation to fail here (as that results in confusing errors). Instead, capture
-            // the error and rethrow it when accessing. This should be JITted away in the common case.
-            var helper = Services.tryLoad(PlatformHelper.class);
-            INSTANCE = helper.instance();
-            ERROR = helper.error();
-        }
-
-        private Instance() {
-        }
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/impl/Services.java

@@ -29,7 +29,7 @@ public final class Services {
      * @throws IllegalStateException When the service cannot be loaded.
      */
     public static <T> T load(Class<T> klass) {
-        var services = ServiceLoader.load(klass).stream().toList();
+        var services = ServiceLoader.load(klass, klass.getClassLoader()).stream().toList();
         return switch (services.size()) {
             case 1 -> services.get(0).get();
             case 0 -> throw new IllegalStateException("Cannot find service for " + klass.getName());

projects/common-api/src/main/java/dan200/computercraft/impl/upgrades/SerialiserWithCraftingItem.java

@@ -1,49 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.impl.upgrades;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.util.GsonHelper;
-import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.ApiStatus;
-
-import java.util.function.BiFunction;
-
-/**
- * Simple serialiser which returns a constant upgrade with a custom crafting item.
- * <p>
- * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
- *
- * @param <T> The upgrade that this class can serialise and deserialise.
- */
-@ApiStatus.Internal
-public abstract class SerialiserWithCraftingItem<T extends UpgradeBase> implements UpgradeSerialiser<T> {
-    private final BiFunction<ResourceLocation, ItemStack, T> factory;
-
-    protected SerialiserWithCraftingItem(BiFunction<ResourceLocation, ItemStack, T> factory) {
-        this.factory = factory;
-    }
-
-    @Override
-    public final T fromJson(ResourceLocation id, JsonObject object) {
-        var item = GsonHelper.getAsItem(object, "item");
-        return factory.apply(id, new ItemStack(item));
-    }
-
-    @Override
-    public final T fromNetwork(ResourceLocation id, FriendlyByteBuf buffer) {
-        var item = buffer.readItem();
-        return factory.apply(id, item);
-    }
-
-    @Override
-    public final void toNetwork(FriendlyByteBuf buffer, T upgrade) {
-        buffer.writeItem(upgrade.getCraftingItem());
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/impl/upgrades/SimpleSerialiser.java

@@ -1,44 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.impl.upgrades;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.resources.ResourceLocation;
-import org.jetbrains.annotations.ApiStatus;
-
-import java.util.function.Function;
-
-/**
- * Simple serialiser which returns a constant upgrade.
- * <p>
- * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
- *
- * @param <T> The upgrade that this class can serialise and deserialise.
- */
-@ApiStatus.Internal
-public abstract class SimpleSerialiser<T extends UpgradeBase> implements UpgradeSerialiser<T> {
-    private final Function<ResourceLocation, T> constructor;
-
-    public SimpleSerialiser(Function<ResourceLocation, T> constructor) {
-        this.constructor = constructor;
-    }
-
-    @Override
-    public final T fromJson(ResourceLocation id, JsonObject object) {
-        return constructor.apply(id);
-    }
-
-    @Override
-    public final T fromNetwork(ResourceLocation id, FriendlyByteBuf buffer) {
-        return constructor.apply(id);
-    }
-
-    @Override
-    public final void toNetwork(FriendlyByteBuf buffer, T upgrade) {
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/impl/upgrades/TurtleToolSpec.java

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.impl.upgrades;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import dan200.computercraft.api.turtle.TurtleToolDurability;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.ComponentSerialization;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.block.Block;
+
+import java.util.Optional;
+
+/**
+ * The template for a turtle tool.
+ *
+ * @param adjective         The adjective for this tool.
+ * @param item              The tool used.
+ * @param damageMultiplier  The damage multiplier for this tool.
+ * @param allowEnchantments Whether to allow enchantments.
+ * @param consumeDurability When to consume durability.
+ * @param breakable         The items breakable by this tool.
+ */
+public record TurtleToolSpec(
+    Component adjective,
+    Item item,
+    float damageMultiplier,
+    boolean allowEnchantments,
+    TurtleToolDurability consumeDurability,
+    Optional<TagKey<Block>> breakable
+) {
+    public static final float DEFAULT_DAMAGE_MULTIPLIER = 3.0f;
+
+    public static final MapCodec<TurtleToolSpec> CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
+        ComponentSerialization.CODEC.fieldOf("adjective").forGetter(TurtleToolSpec::adjective),
+        BuiltInRegistries.ITEM.byNameCodec().fieldOf("item").forGetter(TurtleToolSpec::item),
+        Codec.FLOAT.optionalFieldOf("damageMultiplier", DEFAULT_DAMAGE_MULTIPLIER).forGetter(TurtleToolSpec::damageMultiplier),
+        Codec.BOOL.optionalFieldOf("allowEnchantments", false).forGetter(TurtleToolSpec::allowEnchantments),
+        TurtleToolDurability.CODEC.optionalFieldOf("consumeDurability", TurtleToolDurability.NEVER).forGetter(TurtleToolSpec::consumeDurability),
+        TagKey.codec(Registries.BLOCK).optionalFieldOf("breakable").forGetter(TurtleToolSpec::breakable)
+    ).apply(instance, TurtleToolSpec::new));
+}

projects/common-api/src/main/java/dan200/computercraft/impl/upgrades/UpgradeTypeImpl.java

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.impl.upgrades;
+
+import com.mojang.serialization.MapCodec;
+import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * Simple implementation of {@link UpgradeType}.
+ *
+ * @param codec The codec to read/write upgrades with.
+ * @param <T>   The upgrade subclass that this upgrade type represents.
+ */
+@ApiStatus.Internal
+public record UpgradeTypeImpl<T extends UpgradeBase>(MapCodec<T> codec) implements UpgradeType<T> {
+}

projects/common/build.gradle.kts

@@ -2,16 +2,21 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-import cc.tweaked.gradle.annotationProcessorEverywhere
-import cc.tweaked.gradle.clientClasses
-import cc.tweaked.gradle.commonClasses
+import cc.tweaked.gradle.*
 
 plugins {
     id("cc-tweaked.vanilla")
     id("cc-tweaked.gametest")
+    id("cc-tweaked.illuaminate")
     id("cc-tweaked.publishing")
 }
 
+sourceSets {
+    main {
+        resources.srcDir("src/generated/resources")
+    }
+}
+
 minecraft {
     accessWideners(
         "src/main/resources/computercraft.accesswidener",
@@ -19,16 +24,29 @@ minecraft {
     )
 }
 
+configurations {
+    register("cctJavadoc")
+}
+
+repositories {
+    maven("https://maven.neoforged.net/") {
+        content {
+            includeModule("org.spongepowered", "mixin")
+        }
+    }
+}
+
 dependencies {
     // Pull in our other projects. See comments in MinecraftConfigurations on this nastiness.
     implementation(project(":core"))
     implementation(commonClasses(project(":common-api")))
     clientImplementation(clientClasses(project(":common-api")))
 
+    compileOnly(libs.mixin)
+    compileOnly(libs.mixinExtra)
     compileOnly(libs.bundles.externalMods.common)
     clientCompileOnly(variantOf(libs.emi) { classifier("api") })
 
-    compileOnly(libs.mixin)
     annotationProcessorEverywhere(libs.autoService)
     testFixturesAnnotationProcessor(libs.autoService)
 
@@ -36,9 +54,80 @@ dependencies {
     testImplementation(libs.bundles.test)
     testRuntimeOnly(libs.bundles.testRuntime)
 
+    testImplementation(libs.jmh)
+    testAnnotationProcessor(libs.jmh.processor)
+
+    testModCompileOnly(libs.mixin)
     testModImplementation(testFixtures(project(":core")))
     testModImplementation(testFixtures(project(":common")))
     testModImplementation(libs.bundles.kotlin)
 
     testFixturesImplementation(testFixtures(project(":core")))
+
+    "cctJavadoc"(libs.cctJavadoc)
 }
+
+illuaminate {
+    version.set(libs.versions.illuaminate)
+}
+
+val luaJavadoc by tasks.registering(Javadoc::class) {
+    description = "Generates documentation for Java-side Lua functions."
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+
+    val sourceSets = listOf(sourceSets.main.get(), project(":core").sourceSets.main.get())
+    for (sourceSet in sourceSets) {
+        source(sourceSet.java)
+        classpath += sourceSet.compileClasspath
+    }
+
+    destinationDir = layout.buildDirectory.dir("docs/luaJavadoc").get().asFile
+
+    val options = options as StandardJavadocDocletOptions
+    options.docletpath = configurations["cctJavadoc"].files.toList()
+    options.doclet = "cc.tweaked.javadoc.LuaDoclet"
+    options.addStringOption("project-root", rootProject.file(".").absolutePath)
+    options.noTimestamp(false)
+
+    javadocTool.set(
+        javaToolchains.javadocToolFor {
+            languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
+        },
+    )
+}
+
+val lintLua by tasks.registering(IlluaminateExec::class) {
+    group = JavaBasePlugin.VERIFICATION_GROUP
+    description = "Lint Lua (and Lua docs) with illuaminate"
+
+    // Config files
+    inputs.file(rootProject.file("illuaminate.sexp")).withPropertyName("illuaminate.sexp")
+    // Sources
+    inputs.files(rootProject.fileTree("doc")).withPropertyName("docs")
+    inputs.files(project(":core").fileTree("src/main/resources/data/computercraft/lua")).withPropertyName("lua rom")
+    inputs.files(luaJavadoc)
+
+    args = listOf("lint")
+    workingDir = rootProject.projectDir
+
+    doFirst { if (System.getenv("GITHUB_ACTIONS") != null) println("::add-matcher::.github/matchers/illuaminate.json") }
+    doLast { if (System.getenv("GITHUB_ACTIONS") != null) println("::remove-matcher owner=illuaminate::") }
+}
+
+val runData by tasks.registering(MergeTrees::class) {
+    output = layout.projectDirectory.dir("src/generated/resources")
+
+    for (loader in listOf("forge", "fabric")) {
+        mustRunAfter(":$loader:runData")
+        source {
+            input {
+                from(project(":$loader").layout.buildDirectory.dir("generatedResources"))
+                exclude(".cache")
+            }
+
+            output = project(":$loader").layout.projectDirectory.dir("src/generated/resources")
+        }
+    }
+}
+
+tasks.withType(GenerateModuleMetadata::class).configureEach { isEnabled = false }

projects/common/src/client/java/dan200/computercraft/client/ClientHooks.java

@@ -17,8 +17,6 @@ import dan200.computercraft.client.render.monitor.MonitorRenderState;
 import dan200.computercraft.client.sound.SpeakerManager;
 import dan200.computercraft.shared.CommonHooks;
 import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.command.CommandComputerCraft;
-import dan200.computercraft.shared.computer.core.ServerContext;
 import dan200.computercraft.shared.media.items.PrintoutItem;
 import dan200.computercraft.shared.peripheral.modem.wired.CableBlock;
 import dan200.computercraft.shared.peripheral.modem.wired.CableModemVariant;
@@ -28,7 +26,6 @@ import dan200.computercraft.shared.pocket.items.PocketComputerItem;
 import dan200.computercraft.shared.turtle.blocks.TurtleBlockEntity;
 import dan200.computercraft.shared.util.PauseAwareTimer;
 import dan200.computercraft.shared.util.WorldUtil;
-import net.minecraft.Util;
 import net.minecraft.client.Camera;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.MultiBufferSource;
@@ -43,7 +40,6 @@ import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
 
 import javax.annotation.Nullable;
-import java.io.File;
 import java.util.function.Consumer;
 
 /**
@@ -71,10 +67,6 @@ public final class ClientHooks {
         ClientPocketComputers.reset();
     }
 
-    public static boolean onChatMessage(String message) {
-        return handleOpenComputerCommand(message);
-    }
-
     public static boolean drawHighlight(PoseStack transform, MultiBufferSource bufferSource, Camera camera, BlockHitResult hit) {
         return CableHighlightRenderer.drawHighlight(transform, bufferSource, camera, hit)
             || MonitorHighlightRenderer.drawHighlight(transform, bufferSource, camera, hit);
@@ -109,34 +101,6 @@ public final class ClientHooks {
         SpeakerManager.onPlayStreaming(engine, channel, stream);
     }
 
-    /**
-     * Handle the {@link CommandComputerCraft#OPEN_COMPUTER} "clientside command". This isn't a true command, as we
-     * don't want it to actually be visible to the user.
-     *
-     * @param message The current chat message.
-     * @return Whether to cancel sending this message.
-     */
-    private static boolean handleOpenComputerCommand(String message) {
-        if (!message.startsWith(CommandComputerCraft.OPEN_COMPUTER)) return false;
-
-        var server = Minecraft.getInstance().getSingleplayerServer();
-        if (server == null) return false;
-
-        var idStr = message.substring(CommandComputerCraft.OPEN_COMPUTER.length()).trim();
-        int id;
-        try {
-            id = Integer.parseInt(idStr);
-        } catch (NumberFormatException ignore) {
-            return false;
-        }
-
-        var file = new File(ServerContext.get(server).storageDir().toFile(), "computer/" + id);
-        if (!file.isDirectory()) return false;
-
-        Util.getPlatform().openFile(file);
-        return true;
-    }
-
     /**
      * Add additional information about the currently targeted block to the debug screen.
      *
@@ -144,7 +108,7 @@ public final class ClientHooks {
      */
     public static void addBlockDebugInfo(Consumer<String> addText) {
         var minecraft = Minecraft.getInstance();
-        if (!minecraft.options.renderDebug || minecraft.level == null) return;
+        if (!minecraft.getDebugOverlay().showDebugScreen() || minecraft.level == null) return;
         if (minecraft.hitResult == null || minecraft.hitResult.getType() != HitResult.Type.BLOCK) return;
 
         var tile = minecraft.level.getBlockEntity(((BlockHitResult) minecraft.hitResult).getBlockPos());
@@ -164,8 +128,8 @@ public final class ClientHooks {
     }
 
     private static void addTurtleUpgrade(Consumer<String> out, TurtleBlockEntity turtle, TurtleSide side) {
-        var upgrade = turtle.getUpgrade(side);
-        if (upgrade != null) out.accept(String.format("Upgrade[%s]: %s", side, upgrade.getUpgradeID()));
+        var upgrade = turtle.getAccess().getUpgradeWithData(side);
+        if (upgrade != null) out.accept(String.format("Upgrade[%s]: %s", side, upgrade.holder().key().location()));
     }
 
     /**
@@ -174,7 +138,7 @@ public final class ClientHooks {
      * @param addText A callback which adds a single line of text.
      */
     public static void addGameDebugInfo(Consumer<String> addText) {
-        if (MonitorBlockEntityRenderer.hasRenderedThisFrame() && Minecraft.getInstance().options.renderDebug) {
+        if (MonitorBlockEntityRenderer.hasRenderedThisFrame() && Minecraft.getInstance().getDebugOverlay().showDebugScreen()) {
             addText.accept("[CC:T] Monitor renderer: " + MonitorBlockEntityRenderer.currentRenderer());
         }
     }

projects/common/src/client/java/dan200/computercraft/client/ClientRegistry.java

@@ -4,8 +4,12 @@
 
 package dan200.computercraft.client;
 
+import com.mojang.brigadier.CommandDispatcher;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
 import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.client.ComputerCraftAPIClient;
+import dan200.computercraft.api.client.turtle.RegisterTurtleUpgradeModeller;
 import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
 import dan200.computercraft.client.gui.*;
 import dan200.computercraft.client.pocket.ClientPocketComputers;
@@ -16,29 +20,38 @@ import dan200.computercraft.client.turtle.TurtleModemModeller;
 import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
 import dan200.computercraft.core.util.Colour;
 import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.common.IColouredItem;
+import dan200.computercraft.shared.command.CommandComputerCraft;
+import dan200.computercraft.shared.computer.core.ComputerState;
+import dan200.computercraft.shared.computer.core.ServerContext;
 import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
-import dan200.computercraft.shared.computer.inventory.ViewComputerMenu;
 import dan200.computercraft.shared.media.items.DiskItem;
-import dan200.computercraft.shared.media.items.TreasureDiskItem;
+import net.minecraft.Util;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.color.item.ItemColor;
 import net.minecraft.client.gui.screens.MenuScreens;
+import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.screens.inventory.MenuAccess;
 import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.renderer.ShaderInstance;
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderers;
 import net.minecraft.client.renderer.item.ClampedItemPropertyFunction;
 import net.minecraft.client.renderer.item.ItemProperties;
+import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.packs.resources.PreparableReloadListener;
 import net.minecraft.server.packs.resources.ResourceProvider;
+import net.minecraft.util.FastColor;
 import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.MenuType;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.component.DyedItemColor;
 import net.minecraft.world.level.ItemLike;
 
 import javax.annotation.Nullable;
+import java.io.File;
 import java.io.IOException;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
@@ -60,18 +73,6 @@ public final class ClientRegistry {
      * Register any client-side objects which don't have to be done on the main thread.
      */
     public static void register() {
-        ComputerCraftAPIClient.registerTurtleUpgradeModeller(ModRegistry.TurtleSerialisers.SPEAKER.get(), TurtleUpgradeModeller.sided(
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_speaker_left"),
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_speaker_right")
-        ));
-        ComputerCraftAPIClient.registerTurtleUpgradeModeller(ModRegistry.TurtleSerialisers.WORKBENCH.get(), TurtleUpgradeModeller.sided(
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_crafting_table_left"),
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_crafting_table_right")
-        ));
-        ComputerCraftAPIClient.registerTurtleUpgradeModeller(ModRegistry.TurtleSerialisers.WIRELESS_MODEM_NORMAL.get(), new TurtleModemModeller(false));
-        ComputerCraftAPIClient.registerTurtleUpgradeModeller(ModRegistry.TurtleSerialisers.WIRELESS_MODEM_ADVANCED.get(), new TurtleModemModeller(true));
-        ComputerCraftAPIClient.registerTurtleUpgradeModeller(ModRegistry.TurtleSerialisers.TOOL.get(), TurtleUpgradeModeller.flatItem());
-
         BlockEntityRenderers.register(ModRegistry.BlockEntities.MONITOR_NORMAL.get(), MonitorBlockEntityRenderer::new);
         BlockEntityRenderers.register(ModRegistry.BlockEntities.MONITOR_ADVANCED.get(), MonitorBlockEntityRenderer::new);
         BlockEntityRenderers.register(ModRegistry.BlockEntities.TURTLE_NORMAL.get(), TurtleBlockEntityRenderer::new);
@@ -80,33 +81,62 @@ public final class ClientRegistry {
 
     /**
      * Register any client-side objects which must be done on the main thread.
+     *
+     * @param itemProperties Callback to register item properties.
      */
-    public static void registerMainThread() {
-        MenuScreens.<AbstractComputerMenu, ComputerScreen<AbstractComputerMenu>>register(ModRegistry.Menus.COMPUTER.get(), ComputerScreen::new);
-        MenuScreens.<AbstractComputerMenu, ComputerScreen<AbstractComputerMenu>>register(ModRegistry.Menus.POCKET_COMPUTER.get(), ComputerScreen::new);
-        MenuScreens.<AbstractComputerMenu, NoTermComputerScreen<AbstractComputerMenu>>register(ModRegistry.Menus.POCKET_COMPUTER_NO_TERM.get(), NoTermComputerScreen::new);
-        MenuScreens.register(ModRegistry.Menus.TURTLE.get(), TurtleScreen::new);
-
-        MenuScreens.register(ModRegistry.Menus.PRINTER.get(), PrinterScreen::new);
-        MenuScreens.register(ModRegistry.Menus.DISK_DRIVE.get(), DiskDriveScreen::new);
-        MenuScreens.register(ModRegistry.Menus.PRINTOUT.get(), PrintoutScreen::new);
-
-        MenuScreens.<ViewComputerMenu, ComputerScreen<ViewComputerMenu>>register(ModRegistry.Menus.VIEW_COMPUTER.get(), ComputerScreen::new);
-
-        registerItemProperty("state",
-            new UnclampedPropertyFunction((stack, world, player, random) -> ClientPocketComputers.get(stack).getState().ordinal()),
+    public static void registerMainThread(RegisterItemProperty itemProperties) {
+        registerItemProperty(itemProperties, "state",
+            new UnclampedPropertyFunction((stack, world, player, random) -> {
+                var computer = ClientPocketComputers.get(stack);
+                return (computer == null ? ComputerState.OFF : computer.getState()).ordinal();
+            }),
             ModRegistry.Items.POCKET_COMPUTER_NORMAL, ModRegistry.Items.POCKET_COMPUTER_ADVANCED
         );
-        registerItemProperty("coloured",
-            (stack, world, player, random) -> IColouredItem.getColourBasic(stack) != -1 ? 1 : 0,
+        registerItemProperty(itemProperties, "coloured",
+            (stack, world, player, random) -> DyedItemColor.getOrDefault(stack, -1) != -1 ? 1 : 0,
             ModRegistry.Items.POCKET_COMPUTER_NORMAL, ModRegistry.Items.POCKET_COMPUTER_ADVANCED
         );
     }
 
+    public static void registerMenuScreens(RegisterMenuScreen register) {
+        register.<AbstractComputerMenu, ComputerScreen<AbstractComputerMenu>>register(ModRegistry.Menus.COMPUTER.get(), ComputerScreen::new);
+        register.<AbstractComputerMenu, NoTermComputerScreen<AbstractComputerMenu>>register(ModRegistry.Menus.POCKET_COMPUTER_NO_TERM.get(), NoTermComputerScreen::new);
+        register.register(ModRegistry.Menus.TURTLE.get(), TurtleScreen::new);
+
+        register.register(ModRegistry.Menus.PRINTER.get(), PrinterScreen::new);
+        register.register(ModRegistry.Menus.DISK_DRIVE.get(), DiskDriveScreen::new);
+        register.register(ModRegistry.Menus.PRINTOUT.get(), PrintoutScreen::new);
+    }
+
+    public interface RegisterMenuScreen {
+        <M extends AbstractContainerMenu, U extends Screen & MenuAccess<M>> void register(MenuType<? extends M> type, MenuScreens.ScreenConstructor<M, U> factory);
+    }
+
+    public static void registerTurtleModellers(RegisterTurtleUpgradeModeller register) {
+        register.register(ModRegistry.TurtleUpgradeTypes.SPEAKER.get(), TurtleUpgradeModeller.sided(
+            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_speaker_left"),
+            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_speaker_right")
+        ));
+        register.register(ModRegistry.TurtleUpgradeTypes.WORKBENCH.get(), TurtleUpgradeModeller.sided(
+            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_crafting_table_left"),
+            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "block/turtle_crafting_table_right")
+        ));
+        register.register(ModRegistry.TurtleUpgradeTypes.WIRELESS_MODEM.get(), new TurtleModemModeller());
+        register.register(ModRegistry.TurtleUpgradeTypes.TOOL.get(), TurtleUpgradeModeller.flatItem());
+    }
+
     @SafeVarargs
-    private static void registerItemProperty(String name, ClampedItemPropertyFunction getter, Supplier<? extends Item>... items) {
-        var id = new ResourceLocation(ComputerCraftAPI.MOD_ID, name);
-        for (var item : items) ItemProperties.register(item.get(), id, getter);
+    private static void registerItemProperty(RegisterItemProperty itemProperties, String name, ClampedItemPropertyFunction getter, Supplier<? extends Item>... items) {
+        var id = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name);
+        for (var item : items) itemProperties.register(item.get(), id, getter);
+    }
+
+    /**
+     * Register an item property via {@link ItemProperties#register}. Forge and Fabric expose different methods, so we
+     * supply this via mod-loader-specific code.
+     */
+    public interface RegisterItemProperty {
+        void register(Item item, ResourceLocation name, ClampedItemPropertyFunction property);
     }
 
     public static void registerReloadListeners(Consumer<PreparableReloadListener> register, Minecraft minecraft) {
@@ -121,18 +151,18 @@ public final class ClientRegistry {
     };
 
     public static void registerExtraModels(Consumer<ResourceLocation> register) {
-        for (var model : EXTRA_MODELS) register.accept(new ResourceLocation(ComputerCraftAPI.MOD_ID, model));
+        for (var model : EXTRA_MODELS) register.accept(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, model));
         TurtleUpgradeModellers.getDependencies().forEach(register);
     }
 
     public static void registerItemColours(BiConsumer<ItemColor, ItemLike> register) {
         register.accept(
-            (stack, layer) -> layer == 1 ? ((DiskItem) stack.getItem()).getColour(stack) : 0xFFFFFF,
+            (stack, layer) -> layer == 1 ? DiskItem.getColour(stack) : -1,
             ModRegistry.Items.DISK.get()
         );
 
         register.accept(
-            (stack, layer) -> layer == 1 ? TreasureDiskItem.getColour(stack) : 0xFFFFFF,
+            (stack, layer) -> layer == 1 ? DyedItemColor.getOrDefault(stack, Colour.BLUE.getARGB()) : -1,
             ModRegistry.Items.TREASURE_DISK.get()
         );
 
@@ -144,21 +174,18 @@ public final class ClientRegistry {
     }
 
     private static int getPocketColour(ItemStack stack, int layer) {
-        switch (layer) {
-            case 0:
-            default:
-                return 0xFFFFFF;
-            case 1: // Frame colour
-                return IColouredItem.getColourBasic(stack);
-            case 2: { // Light colour
-                var light = ClientPocketComputers.get(stack).getLightState();
-                return light == -1 ? Colour.BLACK.getHex() : light;
+        return switch (layer) {
+            default -> -1;
+            case 1 -> DyedItemColor.getOrDefault(stack, -1); // Frame colour
+            case 2 -> { // Light colour
+                var computer = ClientPocketComputers.get(stack);
+                yield computer == null || computer.getLightState() == -1 ? Colour.BLACK.getARGB() : FastColor.ARGB32.opaque(computer.getLightState());
             }
-        }
+        };
     }
 
     private static int getTurtleColour(ItemStack stack, int layer) {
-        return layer == 0 ? ((IColouredItem) stack.getItem()).getColour(stack) : 0xFFFFFF;
+        return layer == 0 ? DyedItemColor.getOrDefault(stack, -1) : -1;
     }
 
     public static void registerShaders(ResourceProvider resources, BiConsumer<ShaderInstance, Consumer<ShaderInstance>> load) throws IOException {
@@ -179,4 +206,45 @@ public final class ClientRegistry {
             return function.unclampedCall(stack, level, entity, layer);
         }
     }
+
+    /**
+     * Register client-side commands.
+     *
+     * @param dispatcher The dispatcher to register the commands to.
+     * @param sendError  A function to send an error message.
+     * @param <T>        The type of the client-side command context.
+     */
+    public static <T> void registerClientCommands(CommandDispatcher<T> dispatcher, BiConsumer<T, Component> sendError) {
+        dispatcher.register(LiteralArgumentBuilder.<T>literal(CommandComputerCraft.CLIENT_OPEN_FOLDER)
+            .requires(x -> Minecraft.getInstance().getSingleplayerServer() != null)
+            .then(RequiredArgumentBuilder.<T, Integer>argument("computer_id", IntegerArgumentType.integer(0))
+                .executes(c -> handleOpenComputerCommand(c.getSource(), sendError, c.getArgument("computer_id", Integer.class)))
+            ));
+    }
+
+    /**
+     * Handle the {@link CommandComputerCraft#CLIENT_OPEN_FOLDER} command.
+     *
+     * @param context   The command context.
+     * @param sendError A function to send an error message.
+     * @param id        The computer's id.
+     * @param <T>       The type of the client-side command context.
+     * @return {@code 1} if a folder was opened, {@code 0} otherwise.
+     */
+    private static <T> int handleOpenComputerCommand(T context, BiConsumer<T, Component> sendError, int id) {
+        var server = Minecraft.getInstance().getSingleplayerServer();
+        if (server == null) {
+            sendError.accept(context, Component.literal("Not on a single-player server"));
+            return 0;
+        }
+
+        var file = new File(ServerContext.get(server).storageDir().toFile(), "computer/" + id);
+        if (!file.isDirectory()) {
+            sendError.accept(context, Component.literal("Computer's folder does not exist"));
+            return 0;
+        }
+
+        Util.getPlatform().openFile(file);
+        return 1;
+    }
 }

projects/common/src/client/java/dan200/computercraft/client/ClientTableFormatter.java

@@ -75,7 +75,7 @@ public class ClientTableFormatter implements TableFormatter {
 
         var tag = createTag(table.getId());
         if (chat.allMessages.removeIf(guiMessage -> guiMessage.tag() != null && Objects.equals(guiMessage.tag().logTag(), tag.logTag()))) {
-            chat.refreshTrimmedMessage();
+            chat.rescaleChat();
         }
 
         TableFormatter.super.display(table);

projects/common/src/client/java/dan200/computercraft/client/ComputerCraftAPIClientImpl.java

@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.client;
-
-import com.google.auto.service.AutoService;
-import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
-import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
-import dan200.computercraft.impl.client.ComputerCraftAPIClientService;
-
-@AutoService(ComputerCraftAPIClientService.class)
-public final class ComputerCraftAPIClientImpl implements ComputerCraftAPIClientService {
-    @Override
-    public <T extends ITurtleUpgrade> void registerTurtleUpgradeModeller(TurtleUpgradeSerialiser<T> serialiser, TurtleUpgradeModeller<T> modeller) {
-        TurtleUpgradeModellers.register(serialiser, modeller);
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/gui/AbstractComputerScreen.java

@@ -7,8 +7,9 @@ package dan200.computercraft.client.gui;
 import dan200.computercraft.client.gui.widgets.ComputerSidebar;
 import dan200.computercraft.client.gui.widgets.DynamicImageButton;
 import dan200.computercraft.client.gui.widgets.TerminalWidget;
-import dan200.computercraft.client.platform.ClientPlatformHelper;
+import dan200.computercraft.client.network.ClientNetworking;
 import dan200.computercraft.core.terminal.Terminal;
+import dan200.computercraft.core.util.Nullability;
 import dan200.computercraft.shared.computer.core.ComputerFamily;
 import dan200.computercraft.shared.computer.core.InputHandler;
 import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
@@ -18,7 +19,9 @@ import dan200.computercraft.shared.config.Config;
 import dan200.computercraft.shared.network.server.UploadFileMessage;
 import net.minecraft.ChatFormatting;
 import net.minecraft.Util;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.events.GuiEventListener;
 import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.entity.player.Inventory;
@@ -95,8 +98,8 @@ public abstract class AbstractComputerScreen<T extends AbstractComputerMenu> ext
         getTerminal().update();
 
         if (uploadNagDeadline != Long.MAX_VALUE && Util.getNanos() >= uploadNagDeadline) {
-            new ItemToast(minecraft, displayStack, NO_RESPONSE_TITLE, NO_RESPONSE_MSG, ItemToast.TRANSFER_NO_RESPONSE_TOKEN)
-                .showOrReplace(minecraft.getToasts());
+            new ItemToast(minecraft(), displayStack, NO_RESPONSE_TITLE, NO_RESPONSE_MSG, ItemToast.TRANSFER_NO_RESPONSE_TOKEN)
+                .showOrReplace(minecraft().getToasts());
             uploadNagDeadline = Long.MAX_VALUE;
         }
     }
@@ -124,7 +127,6 @@ public abstract class AbstractComputerScreen<T extends AbstractComputerMenu> ext
 
     @Override
     public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(graphics);
         super.render(graphics, mouseX, mouseY, partialTicks);
         renderTooltip(graphics, mouseX, mouseY);
     }
@@ -144,6 +146,11 @@ public abstract class AbstractComputerScreen<T extends AbstractComputerMenu> ext
             || super.mouseDragged(x, y, button, deltaX, deltaY);
     }
 
+    @Override
+    public void setFocused(@Nullable GuiEventListener listener) {
+        // Don't clear and re-focus if we're already focused.
+        if (listener != getFocused()) super.setFocused(listener);
+    }
 
     @Override
     protected void renderLabels(GuiGraphics graphics, int mouseX, int mouseY) {
@@ -201,7 +208,7 @@ public abstract class AbstractComputerScreen<T extends AbstractComputerMenu> ext
             return;
         }
 
-        if (toUpload.size() > 0) UploadFileMessage.send(menu, toUpload, ClientPlatformHelper.get()::sendToServer);
+        if (!toUpload.isEmpty()) UploadFileMessage.send(menu, toUpload, ClientNetworking::sendToServer);
     }
 
     public void uploadResult(UploadResult result, @Nullable Component message) {
@@ -217,9 +224,13 @@ public abstract class AbstractComputerScreen<T extends AbstractComputerMenu> ext
     }
 
     private void alert(Component title, Component message) {
-        OptionScreen.show(minecraft, title, message,
-            List.of(OptionScreen.newButton(OK, b -> minecraft.setScreen(this))),
-            () -> minecraft.setScreen(this)
+        OptionScreen.show(minecraft(), title, message,
+            List.of(OptionScreen.newButton(OK, b -> minecraft().setScreen(this))),
+            () -> minecraft().setScreen(this)
         );
     }
+
+    private Minecraft minecraft() {
+        return Nullability.assertNonNull(minecraft);
+    }
 }

projects/common/src/client/java/dan200/computercraft/client/gui/ClientInputHandler.java

@@ -4,7 +4,7 @@
 
 package dan200.computercraft.client.gui;
 
-import dan200.computercraft.client.platform.ClientPlatformHelper;
+import dan200.computercraft.client.network.ClientNetworking;
 import dan200.computercraft.shared.computer.core.InputHandler;
 import dan200.computercraft.shared.computer.menu.ComputerMenu;
 import dan200.computercraft.shared.network.server.ComputerActionServerMessage;
@@ -29,51 +29,51 @@ public final class ClientInputHandler implements InputHandler {
 
     @Override
     public void turnOn() {
-        ClientPlatformHelper.get().sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.TURN_ON));
+        ClientNetworking.sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.TURN_ON));
     }
 
     @Override
     public void shutdown() {
-        ClientPlatformHelper.get().sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.SHUTDOWN));
+        ClientNetworking.sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.SHUTDOWN));
     }
 
     @Override
     public void reboot() {
-        ClientPlatformHelper.get().sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.REBOOT));
+        ClientNetworking.sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.REBOOT));
     }
 
     @Override
     public void queueEvent(String event, @Nullable Object[] arguments) {
-        ClientPlatformHelper.get().sendToServer(new QueueEventServerMessage(menu, event, arguments));
+        ClientNetworking.sendToServer(new QueueEventServerMessage(menu, event, arguments));
     }
 
     @Override
     public void keyDown(int key, boolean repeat) {
-        ClientPlatformHelper.get().sendToServer(new KeyEventServerMessage(menu, repeat ? KeyEventServerMessage.TYPE_REPEAT : KeyEventServerMessage.TYPE_DOWN, key));
+        ClientNetworking.sendToServer(new KeyEventServerMessage(menu, repeat ? KeyEventServerMessage.Action.REPEAT : KeyEventServerMessage.Action.DOWN, key));
     }
 
     @Override
     public void keyUp(int key) {
-        ClientPlatformHelper.get().sendToServer(new KeyEventServerMessage(menu, KeyEventServerMessage.TYPE_UP, key));
+        ClientNetworking.sendToServer(new KeyEventServerMessage(menu, KeyEventServerMessage.Action.UP, key));
     }
 
     @Override
     public void mouseClick(int button, int x, int y) {
-        ClientPlatformHelper.get().sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.TYPE_CLICK, button, x, y));
+        ClientNetworking.sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.Action.CLICK, button, x, y));
     }
 
     @Override
     public void mouseUp(int button, int x, int y) {
-        ClientPlatformHelper.get().sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.TYPE_UP, button, x, y));
+        ClientNetworking.sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.Action.UP, button, x, y));
     }
 
     @Override
     public void mouseDrag(int button, int x, int y) {
-        ClientPlatformHelper.get().sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.TYPE_DRAG, button, x, y));
+        ClientNetworking.sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.Action.DRAG, button, x, y));
     }
 
     @Override
     public void mouseScroll(int direction, int x, int y) {
-        ClientPlatformHelper.get().sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.TYPE_SCROLL, direction, x, y));
+        ClientNetworking.sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.Action.SCROLL, direction, x, y));
     }
 }

projects/common/src/client/java/dan200/computercraft/client/gui/DiskDriveScreen.java

@@ -15,7 +15,7 @@ import net.minecraft.world.entity.player.Inventory;
  * The GUI for disk drives.
  */
 public class DiskDriveScreen extends AbstractContainerScreen<DiskDriveMenu> {
-    private static final ResourceLocation BACKGROUND = new ResourceLocation("computercraft", "textures/gui/disk_drive.png");
+    private static final ResourceLocation BACKGROUND = ResourceLocation.fromNamespaceAndPath("computercraft", "textures/gui/disk_drive.png");
 
     public DiskDriveScreen(DiskDriveMenu container, Inventory player, Component title) {
         super(container, player, title);
@@ -28,7 +28,6 @@ public class DiskDriveScreen extends AbstractContainerScreen<DiskDriveMenu> {
 
     @Override
     public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(graphics);
         super.render(graphics, mouseX, mouseY, partialTicks);
         renderTooltip(graphics, mouseX, mouseY);
     }

projects/common/src/client/java/dan200/computercraft/client/gui/GuiSprites.java

@@ -21,7 +21,7 @@ import java.util.stream.Stream;
  * Sprite sheet for all GUI texutres in the mod.
  */
 public final class GuiSprites extends TextureAtlasHolder {
-    public static final ResourceLocation SPRITE_SHEET = new ResourceLocation(ComputerCraftAPI.MOD_ID, "gui");
+    public static final ResourceLocation SPRITE_SHEET = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "gui");
     public static final ResourceLocation TEXTURE = SPRITE_SHEET.withPath(x -> "textures/atlas/" + x + ".png");
 
     public static final ButtonTextures TURNED_OFF = button("turned_off");
@@ -35,16 +35,16 @@ public final class GuiSprites extends TextureAtlasHolder {
 
     private static ButtonTextures button(String name) {
         return new ButtonTextures(
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "gui/buttons/" + name),
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "gui/buttons/" + name + "_hover")
+            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "gui/buttons/" + name),
+            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "gui/buttons/" + name + "_hover")
         );
     }
 
     private static ComputerTextures computer(String name, boolean pocket, boolean sidebar) {
         return new ComputerTextures(
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "gui/border_" + name),
-            pocket ? new ResourceLocation(ComputerCraftAPI.MOD_ID, "gui/pocket_bottom_" + name) : null,
-            sidebar ? new ResourceLocation(ComputerCraftAPI.MOD_ID, "gui/sidebar_" + name) : null
+            ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "gui/border_" + name),
+            pocket ? ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "gui/pocket_bottom_" + name) : null,
+            sidebar ? ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "gui/sidebar_" + name) : null
         );
     }
 

projects/common/src/client/java/dan200/computercraft/client/gui/ItemToast.java

@@ -9,6 +9,7 @@ import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.components.toasts.Toast;
 import net.minecraft.client.gui.components.toasts.ToastComponent;
 import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.util.FormattedCharSequence;
 import net.minecraft.world.item.ItemStack;
 
@@ -18,6 +19,7 @@ import java.util.List;
  * A {@link Toast} implementation which displays an arbitrary message along with an optional {@link ItemStack}.
  */
 public class ItemToast implements Toast {
+    private static final ResourceLocation TEXTURE = ResourceLocation.withDefaultNamespace("toast/recipe");
     public static final Object TRANSFER_NO_RESPONSE_TOKEN = new Object();
 
     private static final long DISPLAY_TIME = 7000L;
@@ -79,7 +81,7 @@ public class ItemToast implements Toast {
         }
 
         if (width == 160 && message.size() <= 1) {
-            graphics.blit(TEXTURE, 0, 0, 0, 64, width, height());
+            graphics.blitSprite(TEXTURE, 0, 0, width, height());
         } else {
 
             var height = height();
@@ -109,14 +111,14 @@ public class ItemToast implements Toast {
     }
 
     private static void renderBackgroundRow(GuiGraphics graphics, int x, int u, int y, int height) {
-        var leftOffset = 5;
+        var leftOffset = u == 0 ? 20 : 5;
         var rightOffset = Math.min(60, x - leftOffset);
 
-        graphics.blit(TEXTURE, 0, y, 0, 32 + u, leftOffset, height);
+        graphics.blitSprite(TEXTURE, 160, 32, 0, u, 0, y, leftOffset, height);
         for (var k = leftOffset; k < x - rightOffset; k += 64) {
-            graphics.blit(TEXTURE, k, y, 32, 32 + u, Math.min(64, x - k - rightOffset), height);
+            graphics.blitSprite(TEXTURE, 160, 32, 32, u, k, y, Math.min(64, x - k - rightOffset), height);
         }
 
-        graphics.blit(TEXTURE, x - rightOffset, y, 160 - rightOffset, 32 + u, rightOffset, height);
+        graphics.blitSprite(TEXTURE, 160, 32, 160 - rightOffset, u, x - rightOffset, y, rightOffset, height);
     }
 }

projects/common/src/client/java/dan200/computercraft/client/gui/NoTermComputerScreen.java

@@ -6,8 +6,10 @@ package dan200.computercraft.client.gui;
 
 import dan200.computercraft.client.gui.widgets.TerminalWidget;
 import dan200.computercraft.core.terminal.Terminal;
+import dan200.computercraft.core.util.Nullability;
 import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
 import net.minecraft.client.KeyMapping;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.screens.Screen;
 import net.minecraft.client.gui.screens.inventory.MenuAccess;
@@ -16,6 +18,7 @@ import net.minecraft.world.entity.player.Inventory;
 import org.lwjgl.glfw.GLFW;
 
 import javax.annotation.Nullable;
+import java.util.Objects;
 
 import static dan200.computercraft.core.util.Nullability.assertNonNull;
 
@@ -44,8 +47,8 @@ public class NoTermComputerScreen<T extends AbstractComputerMenu> extends Screen
     protected void init() {
         // First ensure we're still grabbing the mouse, so the user can look around. Then reset bits of state that
         // grabbing unsets.
-        minecraft.mouseHandler.grabMouse();
-        minecraft.screen = this;
+        minecraft().mouseHandler.grabMouse();
+        minecraft().screen = this;
         KeyMapping.releaseAll();
 
         super.init();
@@ -63,14 +66,14 @@ public class NoTermComputerScreen<T extends AbstractComputerMenu> extends Screen
     }
 
     @Override
-    public boolean mouseScrolled(double pMouseX, double pMouseY, double pDelta) {
-        minecraft.player.getInventory().swapPaint(pDelta);
-        return super.mouseScrolled(pMouseX, pMouseY, pDelta);
+    public boolean mouseScrolled(double mouseX, double mouseY, double scrollX, double scrollY) {
+        Objects.requireNonNull(minecraft().player).getInventory().swapPaint(scrollY);
+        return super.mouseScrolled(mouseX, mouseY, scrollX, scrollY);
     }
 
     @Override
     public void onClose() {
-        minecraft.player.closeContainer();
+        Objects.requireNonNull(minecraft().player).closeContainer();
         super.onClose();
     }
 
@@ -93,12 +96,21 @@ public class NoTermComputerScreen<T extends AbstractComputerMenu> extends Screen
     public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
         super.render(graphics, mouseX, mouseY, partialTicks);
 
-        var font = minecraft.font;
+        var font = minecraft().font;
         var lines = font.split(Component.translatable("gui.computercraft.pocket_computer_overlay"), (int) (width * 0.8));
         var y = 10;
         for (var line : lines) {
-            graphics.drawString(font, line, (width / 2) - (minecraft.font.width(line) / 2), y, 0xFFFFFF, true);
+            graphics.drawString(font, line, (width / 2) - (font.width(line) / 2), y, 0xFFFFFF, true);
             y += 9;
         }
     }
+
+    @Override
+    public void renderBackground(GuiGraphics guiGraphics, int mouseX, int mouseY, float partialTick) {
+        // Skip rendering the background.
+    }
+
+    private Minecraft minecraft() {
+        return Nullability.assertNonNull(minecraft);
+    }
 }

projects/common/src/client/java/dan200/computercraft/client/gui/OptionScreen.java

@@ -24,7 +24,7 @@ import static dan200.computercraft.core.util.Nullability.assertNonNull;
  * When closed, it returns to the previous screen.
  */
 public final class OptionScreen extends Screen {
-    private static final ResourceLocation BACKGROUND = new ResourceLocation("computercraft", "textures/gui/blank_screen.png");
+    private static final ResourceLocation BACKGROUND = ResourceLocation.fromNamespaceAndPath("computercraft", "textures/gui/blank_screen.png");
 
     public static final int BUTTON_WIDTH = 100;
     public static final int BUTTON_HEIGHT = 20;
@@ -86,8 +86,6 @@ public final class OptionScreen extends Screen {
 
     @Override
     public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(graphics);
-
         // Render the actual texture.
         graphics.blit(BACKGROUND, x, y, 0, 0, innerWidth, PADDING);
         graphics.blit(BACKGROUND,

projects/common/src/client/java/dan200/computercraft/client/gui/PrinterScreen.java

@@ -15,7 +15,7 @@ import net.minecraft.world.entity.player.Inventory;
  * The GUI for printers.
  */
 public class PrinterScreen extends AbstractContainerScreen<PrinterMenu> {
-    private static final ResourceLocation BACKGROUND = new ResourceLocation("computercraft", "textures/gui/printer.png");
+    private static final ResourceLocation BACKGROUND = ResourceLocation.fromNamespaceAndPath("computercraft", "textures/gui/printer.png");
 
     public PrinterScreen(PrinterMenu container, Inventory player, Component title) {
         super(container, player, title);
@@ -30,7 +30,6 @@ public class PrinterScreen extends AbstractContainerScreen<PrinterMenu> {
 
     @Override
     public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(graphics);
         super.render(graphics, mouseX, mouseY, partialTicks);
         renderTooltip(graphics, mouseX, mouseY);
     }

projects/common/src/client/java/dan200/computercraft/client/gui/PrintoutScreen.java

@@ -4,13 +4,13 @@
 
 package dan200.computercraft.client.gui;
 
-import com.mojang.blaze3d.vertex.Tesselator;
 import dan200.computercraft.core.terminal.TextBuffer;
+import dan200.computercraft.shared.ModRegistry;
 import dan200.computercraft.shared.common.HeldItemMenu;
+import dan200.computercraft.shared.media.items.PrintoutData;
 import dan200.computercraft.shared.media.items.PrintoutItem;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.client.renderer.MultiBufferSource;
 import net.minecraft.network.chat.Component;
 import net.minecraft.world.entity.player.Inventory;
 import org.lwjgl.glfw.GLFW;
@@ -35,16 +35,17 @@ public class PrintoutScreen extends AbstractContainerScreen<HeldItemMenu> {
 
         imageHeight = Y_SIZE;
 
-        var text = PrintoutItem.getText(container.getStack());
-        this.text = new TextBuffer[text.length];
-        for (var i = 0; i < this.text.length; i++) this.text[i] = new TextBuffer(text[i]);
-
-        var colours = PrintoutItem.getColours(container.getStack());
-        this.colours = new TextBuffer[colours.length];
-        for (var i = 0; i < this.colours.length; i++) this.colours[i] = new TextBuffer(colours[i]);
+        var printout = container.getStack().getOrDefault(ModRegistry.DataComponents.PRINTOUT.get(), PrintoutData.EMPTY);
+        this.text = new TextBuffer[printout.lines().size()];
+        this.colours = new TextBuffer[printout.lines().size()];
+        for (var i = 0; i < this.text.length; i++) {
+            var line = printout.lines().get(i);
+            this.text[i] = new TextBuffer(line.text());
+            this.colours[i] = new TextBuffer(line.foreground());
+        }
 
         page = 0;
-        pages = Math.max(this.text.length / PrintoutItem.LINES_PER_PAGE, 1);
+        pages = Math.max(this.text.length / PrintoutData.LINES_PER_PAGE, 1);
         book = ((PrintoutItem) container.getStack().getItem()).getType() == PrintoutItem.Type.BOOK;
     }
 
@@ -64,15 +65,15 @@ public class PrintoutScreen extends AbstractContainerScreen<HeldItemMenu> {
     }
 
     @Override
-    public boolean mouseScrolled(double x, double y, double delta) {
-        if (super.mouseScrolled(x, y, delta)) return true;
-        if (delta < 0) {
+    public boolean mouseScrolled(double x, double y, double deltaX, double deltaY) {
+        if (super.mouseScrolled(x, y, deltaX, deltaY)) return true;
+        if (deltaY < 0) {
             // Scroll up goes to the next page
             if (page < pages - 1) page++;
             return true;
         }
 
-        if (delta > 0) {
+        if (deltaY > 0) {
             // Scroll down goes to the previous page
             if (page > 0) page--;
             return true;
@@ -83,22 +84,14 @@ public class PrintoutScreen extends AbstractContainerScreen<HeldItemMenu> {
 
     @Override
     protected void renderBg(GuiGraphics graphics, float partialTicks, int mouseX, int mouseY) {
-        // Draw the printout
-        var renderer = MultiBufferSource.immediate(Tesselator.getInstance().getBuilder());
-        drawBorder(graphics.pose(), renderer, leftPos, topPos, 0, page, pages, book, FULL_BRIGHT_LIGHTMAP);
-        drawText(graphics.pose(), renderer, leftPos + X_TEXT_MARGIN, topPos + Y_TEXT_MARGIN, PrintoutItem.LINES_PER_PAGE * page, FULL_BRIGHT_LIGHTMAP, text, colours);
-        renderer.endBatch();
-    }
-
-    @Override
-    public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        // We must take the background further back in order to not overlap with our printed pages.
+        // Push the printout slightly forward, to avoid clipping into the background.
         graphics.pose().pushPose();
-        graphics.pose().translate(0, 0, -1);
-        renderBackground(graphics);
-        graphics.pose().popPose();
+        graphics.pose().translate(0, 0, 1);
 
-        super.render(graphics, mouseX, mouseY, partialTicks);
+        drawBorder(graphics.pose(), graphics.bufferSource(), leftPos, topPos, 0, page, pages, book, FULL_BRIGHT_LIGHTMAP);
+        drawText(graphics.pose(), graphics.bufferSource(), leftPos + X_TEXT_MARGIN, topPos + Y_TEXT_MARGIN, PrintoutData.LINES_PER_PAGE * page, FULL_BRIGHT_LIGHTMAP, text, colours);
+
+        graphics.pose().popPose();
     }
 
     @Override

projects/common/src/client/java/dan200/computercraft/client/gui/TurtleScreen.java

@@ -23,8 +23,8 @@ import static dan200.computercraft.shared.turtle.inventory.TurtleMenu.*;
  * The GUI for turtles.
  */
 public class TurtleScreen extends AbstractComputerScreen<TurtleMenu> {
-    private static final ResourceLocation BACKGROUND_NORMAL = new ResourceLocation(ComputerCraftAPI.MOD_ID, "textures/gui/turtle_normal.png");
-    private static final ResourceLocation BACKGROUND_ADVANCED = new ResourceLocation(ComputerCraftAPI.MOD_ID, "textures/gui/turtle_advanced.png");
+    private static final ResourceLocation BACKGROUND_NORMAL = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "textures/gui/turtle_normal.png");
+    private static final ResourceLocation BACKGROUND_ADVANCED = ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "textures/gui/turtle_advanced.png");
 
     private static final int TEX_WIDTH = 278;
     private static final int TEX_HEIGHT = 217;

projects/common/src/client/java/dan200/computercraft/client/gui/widgets/DynamicImageButton.java

@@ -43,6 +43,10 @@ public class DynamicImageButton extends Button {
 
     @Override
     public void renderWidget(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
+        var message = this.message.get();
+        setMessage(message.message());
+        setTooltip(message.tooltip());
+
         var texture = this.texture.get(isHoveredOrFocused());
 
         RenderSystem.disableDepthTest();
@@ -50,14 +54,6 @@ public class DynamicImageButton extends Button {
         RenderSystem.enableDepthTest();
     }
 
-    @Override
-    public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTicks) {
-        var message = this.message.get();
-        setMessage(message.message());
-        setTooltip(message.tooltip());
-        super.render(graphics, mouseX, mouseY, partialTicks);
-    }
-
     public record HintedMessage(Component message, Tooltip tooltip) {
         public HintedMessage(Component message, @Nullable Component hint) {
             this(