Merge branch 'mc-1.18.x' into mc-1.19.2

Yes, it was the shiny parse errors, and not the steady accumulation of
bugs which made me finally do a version bump.

.editorconfig

@@ -8,17 +8,6 @@ charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
 
-ij_continuation_indent_size = 4
-ij_any_do_while_brace_force = if_multiline
-ij_any_if_brace_force = if_multiline
-ij_any_for_brace_force = if_multiline
-ij_any_spaces_within_array_initializer_braces = true
-
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true
-ij_kotlin_method_parameters_wrap = off
-ij_kotlin_call_parameters_wrap = off
-
 [*.md]
 trim_trailing_whitespace = false
 

.git-blame-ignore-revs

@@ -1,2 +0,0 @@
-# Reformat everything
-f478c4ffc4fb9fc2200ec9b0bc751d047057ce81

.gitattributes

@@ -1,6 +1,6 @@
 # Ignore changes in generated files
-projects/*/src/generated/** linguist-generated
-projects/common/src/testMod/resources/data/cctest/structures/* linguist-generated
+src/generated/** linguist-generated
+src/testMod/server-files/structures linguist-generated
 
 * text=auto
 

.github/workflows/main-ci.yml

@@ -33,19 +33,14 @@ jobs:
         ./gradlew downloadAssets || ./gradlew downloadAssets
         ./gradlew build
 
-    - name: Run client tests
-      run: ./gradlew runGametestClient # Not checkClient, as no point running rendering tests.
-      # These are a little flaky on GH actions: its useful to run them, but don't break the build.
-      continue-on-error: true
-
     - name: Upload Jar
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v2
       with:
         name: CC-Tweaked
-        path: projects/forge/build/libs
+        path: build/libs
 
     - name: Upload coverage
-      uses: codecov/codecov-action@v3
+      uses: codecov/codecov-action@v2
 
     - name: Parse test reports
       run: ./tools/parse-reports.py
@@ -53,40 +48,3 @@ jobs:
 
     - name: Run linters
       uses: pre-commit/action@v3.0.0
-
-  build-core:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-        - name: Windows
-          uses: windows-latest
-
-        - name: macOS
-          uses: macos-latest
-
-    name: Test on ${{ matrix.name }}
-    runs-on: ${{ matrix.uses }}
-
-    steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
-
-    - name: Set up Java
-      uses: actions/setup-java@v3
-      with:
-        java-version: 17
-        distribution: 'temurin'
-
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2
-      with:
-        cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
-
-    - name: Run tests
-      run: |
-        ./gradlew --configure-on-demand :core:test
-
-    - name: Parse test reports
-      run: python3 ./tools/parse-reports.py
-      if: ${{ failure() }}

.github/workflows/make-doc.sh

@@ -12,8 +12,8 @@ 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/" \
+      "$GITHUB_WORKSPACE/build/docs/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/" \
+      "$GITHUB_WORKSPACE/build/docs/javadoc/" \
       "$SSH_USER@$SSH_HOST:/$DEST/javadoc"

.github/workflows/make-doc.yml

@@ -3,7 +3,7 @@ name: Build documentation
 on:
   push:
     branches:
-    - mc-1.19.x
+    - mc-1.16.x
 
 jobs:
   make_doc:
@@ -29,7 +29,7 @@ jobs:
       run: ./gradlew compileJava --no-daemon || ./gradlew compileJava --no-daemon
 
     - name: Generate documentation
-      run: ./gradlew docWebsite :common-api:javadoc  --no-daemon
+      run: ./gradlew docWebsite javadoc --no-daemon
 
     - name: Upload documentation
       run: .github/workflows/make-doc.sh 2> /dev/null

.gitignore

@@ -2,17 +2,15 @@
 /classes
 /logs
 /build
-/projects/*/logs
-/projects/*/build
 /buildSrc/build
 /out
 /doc/out/
 /node_modules
-.jqwik-database
+/.jqwik-database
 
 # Runtime directories
 /run
-/projects/*/run
+/run-*
 
 *.ipr
 *.iws
@@ -25,6 +23,8 @@
 /.project
 /.settings
 /.vscode
+bin/
 *.launch
 
-/projects/*/src/generated/resources/.cache
+/src/generated/resources/.cache
+/src/web/mount/*.d.ts

.pre-commit-config.yaml

@@ -48,7 +48,9 @@ repos:
 
 exclude: |
   (?x)^(
-    projects/[a-z]+/src/generated|
-    projects/core/src/test/resources/test-rom/data/json-parsing/|
+    src/generated|
+    src/test/resources/test-rom/data/json-parsing/|
+    src/testMod/server-files/|
+    config/idea/|
     .*\.dfpwm
   )

CONTRIBUTING.md

@@ -4,96 +4,96 @@ provides an introduction as to how to get started in helping out.
 
 If you've any other questions, [just ask the community][community] or [open an issue][new-issue].
 
-## Table of Contents
- - [Reporting issues](#reporting-issues)
- - [Translations](#translations)
- - [Setting up a development environment](#setting-up-a-development-environment)
- - [Developing CC: Tweaked](#developing-cc-tweaked)
- - [Writing documentation](#writing-documentation)
-
 ## Reporting issues
-If you have a bug, suggestion, or other feedback, the best thing to do is [file an issue][new-issue]. When doing so, do
-use the issue templates - they provide a useful hint on what information to provide.
+If you have a bug, suggestion, or other feedback, the best thing to do is [file an issue][new-issue]. When doing so,
+do use the issue templates - they provide a useful hint on what information to provide.
 
 ## Translations
 Translations are managed through [Weblate], an online interface for managing language strings. This is synced
 automatically with GitHub, so please don't submit PRs adding/changing translations!
 
-## Setting up a development environment
-In order to develop CC: Tweaked, you'll need to download the source code and then run it.
+## Developing
+In order to develop CC: Tweaked, you'll need to download the source code and then run it. This is a pretty simple
+process. When building on Windows, Use `gradlew.bat` instead of `./gradlew`.
 
- - Make sure you've got the following software instealled:
-   - Java Development Kit (JDK) installed. This can be downloaded from [Adoptium].
-   - [Git](https://git-scm.com/).
-   - If you want to work on documentation, [NodeJS][node].
+ - **Clone the repository:** `git clone https://github.com/cc-tweaked/CC-Tweaked.git && cd CC-Tweaked`
+ - **Setup Forge:** `./gradlew build`
+ - **Run Minecraft:** `./gradlew runClient` (or run the `GradleStart` class from your IDE).
+ - **Optionally:** For small PRs (especially those only touching Lua code), it may be easier to use GitPod, which
+   provides a pre-configured environment: [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-2b2b2b?logo=gitpod)](https://gitpod.io/#https://github.com/cc-tweaked/CC-Tweaked/)
 
- - Download CC: Tweaked's source code:
-   ```
-   git clone https://github.com/cc-tweaked/CC-Tweaked.git
-   cd CC-Tweaked
-   ```
+   Do note you will need to download the mod after compiling to test.
 
- - Build CC: Tweaked with `./gradlew build`. This will be very slow the first time it runs, as it needs to download a
-   lot of dependencies (and decompile Minecraft several times). Subsequent runs should be much faster!
+If you want to run CC:T in a normal Minecraft instance, run `./gradlew build` and copy the `.jar` from `build/libs`.
+These commands may take a few minutes to run the first time, as the environment is set up, but should be much faster
+afterwards.
 
- - You're now ready to start developing CC: Tweaked. Running `./gradlew :forge:runClient` or
-   `./gradle :fabric:runClient` will start Minecraft under Forge and Fabric respectively.
+The following sections describe the more niche sections of CC: Tweaked's build system. Some bits of these are
+quite-complex, and (dare I say) over-engineered, so you may wish to ignore them. Well tested/documented PRs are always
+preferred (and I'd definitely recommend setting up the tooling if you're doing serious development work), but for
+small changes it can be a lot.
 
-If you want to run CC:T in a normal Minecraft instance, run `./gradlew assemble` and copy the `.jar` from
-`projects/forge/build/libs` (for Forge) or `projects/fabric/build/libs` (for Fabric).
+### Code linters
+CC: Tweaked uses a couple of "linters" on its source code, to enforce a consistent style across the project. While these
+are run whenever you submit a PR, it's often useful to run this before committing.
 
-## Developing CC: Tweaked
-Before making any major changes to CC: Tweaked, I'd recommend you have a read of the [the architecture
-document][architecture] first. While it's not a comprehensive document, it gives a good hint of where you should start
-looking to make your changes. As always, if you're not sure [do ask the community][community]!
+ - **[Checkstyle]:** Checks Java code to ensure it is consistently formatted. This can be run with `./gradlew build` or
+   `./gradle check`.
+ - **[illuaminate]:** Checks Lua code for semantic and styleistic issues. This can be run with `./gradlew lintLua`.
 
-### Testing
-When making larger changes, it's may be useful to write a test to make sure your code works as expected.
-
-CC: Tweaked has several test suites, each designed to test something different:
-
- - In order to test CraftOS and its builtin APIs, we have a test suite written in Lua located at
-   `projects/core/src/test/resources/test-rom/`. These don't rely on any Minecraft code, which means they can run on
-   emulators, acting as a sort of compliance test.
-
-   These tests are written using a test system called "mcfly", heavily inspired by [busted]. Groups of tests go inside
-   `describe` blocks, and a single test goes inside `it`. Assertions are generally written using `expect` (inspired by
-   Hamcrest and the like). For instance, `expect(foo):eq("bar")` asserts that your variable `foo` is equal to the
-   expected value `"bar"`.
-
-   These tests can be run with `./gradlew :core:test`.
-
- - In-game functionality, such as the behaviour of blocks and items, is tested using [Minecraft's gametest
-   system][mc-test] (`projects/common/src/testMod`). These tests spin up a server, spawn a structure for each test, and
-   then run some code on the blocks defined in that structure.
-
-   These tests can be run with `./gradlew runGametest` (or `./gradle :forge:runGametest`/`./gradlew :fabric:runGametest`
-   for a single loader).
-
-For more information, [see the architecture document][architecture].
-
-## Writing documentation
+### Documentation
 When writing documentation for [CC: Tweaked's documentation website][docs], it may be useful to build the documentation
 and preview it yourself before submitting a PR.
 
-You'll first need to [set up a development environment as above](#setting-up-a-development-environment).
+Our documentation generation pipeline is rather complex, and involves invoking several external tools. Most of this
+complexity is hidden by Gradle, but you will need to perform some initial setup:
 
-Once this is set up, you can now run `./gradlew docWebsite`. This generates documentation from our Lua and Java code,
-writing the resulting HTML into `./projects/web/build/site`, which can then be opened in a browser. When iterating on
-documentation, you can instead run `./gradlew docWebsite -t`, which will rebuild documentation every time you change a
-file.
+ - Install [Node/npm][node].
+ - Run `npm ci` to install our Node dependencies.
 
-Documentation is built using [illuaminate] which, while not currently documented (somewhat ironic), is largely the same
-as [ldoc][ldoc]. Documentation comments are written in Markdown, though note that we do not support many GitHub-specific
-markdown features - if you can, do check what the documentation looks like locally!
+You can now run `./gradlew docWebsite`. This generates documentation from our Lua and Java code, writing the resulting
+HTML into `./build/docs/site`.
 
-When writing long-form documentation (such as the guides in [doc/guides](doc/guides)), I find it useful to tell a
-narrative. Think of what you want the user to learn or achieve, then start introducing a simple concept and then talk
-about how you can build on that, until you've covered everything!
+#### Writing documentation
+illuaminate's documentation system is not currently documented (somewhat ironic), but is _largely_ the same as
+[ldoc][ldoc]. Documentation comments are written in Markdown,
+
+Our markdown engine does _not_ support GitHub flavoured markdown, and so does not support all the features one might
+expect. It is recommended that you build and preview the docs locally first.
+
+When iterating on documentation, you can get Gradle to rebuild the website every time a file changes by running
+`./gradlew docWebsite -t`. This will take a couple of seconds to run, but definitely beats running it manually!
+
+### Testing
+Thankfully running tests is much simpler than running the documentation generator! `./gradlew check` will run the
+entire test suite (and some additional bits of verification).
+
+Before we get into writing tests, it's worth mentioning the various test suites that CC: Tweaked has:
+ - "Core" Java (`./src/test/java`): These test core bits of the mod which don't require any Minecraft interaction.
+   This includes the `@LuaFunction` system, file system code, etc...
+
+   These tests are run by `./gradlew test`.
+
+ - CraftOS (`./src/test/resources/test-rom/`): These tests are written in Lua, and ensure the Lua environment, libraries
+   and programs work as expected. These are (generally) written to be able to be run on emulators too, to provide some
+   sort of compliance test.
+
+   These tests are run by the '"Core" Java' test suite, and so are also run with `./gradlew test`.
+
+ - In-game (`./src/testMod/java/dan200/computercraft/ingame/`): These tests are run on an actual Minecraft server, using
+   the same system Mojang do][mc-test]. The aim of these is to test in-game behaviour of blocks and peripherals.
+
+   These tests are run with `./gradlew runGametest`.
+
+## CraftOS tests
+CraftOS's tests are written using a test system called "mcfly", heavily inspired by [busted] (and thus RSpec). Groups of
+tests go inside `describe` blocks, and a single test goes inside `it`.
+
+Assertions are generally written using `expect` (inspired by Hamcrest and the like). For instance, `expect(foo):eq("bar")`
+asserts that your variable `foo` is equal to the expected value `"bar"`.
 
 [new-issue]: https://github.com/cc-tweaked/CC-Tweaked/issues/new/choose "Create a new issue"
-[community]: README.md#community "Get in touch with the community."
-[Adoptium]: https://adoptium.net/temurin/releases?version=17 "Download OpenJDK 17"
+[community]: README.md#Community "Get in touch with the community."
 [checkstyle]: https://checkstyle.org/
 [illuaminate]: https://github.com/SquidDev/illuaminate/ "Illuaminate on GitHub"
 [weblate]: https://i18n.tweaked.cc/projects/cc-tweaked/minecraft/ "CC: Tweaked weblate instance"
@@ -102,4 +102,3 @@ about how you can build on that, until you've covered everything!
 [mc-test]: https://www.youtube.com/watch?v=vXaWOJTCYNg
 [busted]: https://github.com/Olivine-Labs/busted "busted: Elegant Lua unit testing."
 [node]: https://nodejs.org/en/ "Node.js"
-[architecture]: projects/ARCHITECTURE.md

README.md

@@ -26,26 +26,16 @@ on is present.
 ```groovy
 repositories {
   maven {
-    url "https://squiddev.cc/maven/"
+    url 'https://squiddev.cc/maven/'
     content {
-      includeGroup("cc.tweaked")
-      includeModule("org.squiddev", "Cobalt")
-      includeModule("fuzs.forgeconfigapiport", "forgeconfigapiport-fabric")
+      includeGroup 'org.squiddev'
     }
   }
 }
 
 dependencies {
-  // Vanilla (i.e. for multi-loader systems)
-  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-common-api")
-
-  // Forge Gradle
-  compileOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion"))
-  runtimeOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion"))
-
-  // Fabric Loom
-  modCompileOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric-api:$cctVersion")
-  modRuntimeOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric:$cctVersion")
+  compileOnly fg.deobf("org.squiddev:cc-tweaked-${mc_version}:${cct_version}:api")
+  runtimeOnly fg.deobf("org.squiddev:cc-tweaked-${mc_version}:${cct_version}")
 }
 ```
 

build.gradle.kts

@@ -1,18 +1,402 @@
-import org.jetbrains.gradle.ext.compiler
-import org.jetbrains.gradle.ext.settings
+import cc.tweaked.gradle.*
+import net.darkhax.curseforgegradle.TaskPublishCurseForge
+import net.minecraftforge.gradle.common.util.RunConfig
 
 plugins {
-    publishing
-    alias(libs.plugins.taskTree)
+    // Build
+    alias(libs.plugins.forgeGradle)
+    alias(libs.plugins.mixinGradle)
+    alias(libs.plugins.librarian)
+    alias(libs.plugins.shadow)
+    // Publishing
+    `maven-publish`
+    alias(libs.plugins.curseForgeGradle)
     alias(libs.plugins.githubRelease)
-    id("org.jetbrains.gradle.plugin.idea-ext")
+    alias(libs.plugins.minotaur)
+    // Utility
+    alias(libs.plugins.taskTree)
+
+    id("cc-tweaked.illuaminate")
+    id("cc-tweaked.node")
+    id("cc-tweaked.gametest")
     id("cc-tweaked")
 }
 
-val isUnstable = project.properties["isUnstable"] == "true"
+val isStable = true
 val modVersion: String by extra
 val mcVersion: String by extra
 
+group = "org.squiddev"
+version = modVersion
+base.archivesName.set("cc-tweaked-$mcVersion")
+
+java.registerFeature("extraMods") { usingSourceSet(sourceSets.main.get()) }
+
+sourceSets {
+    main {
+        resources.srcDir("src/generated/resources")
+    }
+}
+
+minecraft {
+    runs {
+        // configureEach would be better, but we need to eagerly configure configs or otherwise the run task doesn't
+        // get set up properly.
+        all {
+            lazyToken("minecraft_classpath") {
+                configurations["shade"].copyRecursive().resolve().joinToString(File.pathSeparator) { it.absolutePath }
+            }
+
+            property("forge.logging.markers", "REGISTRIES")
+            property("forge.logging.console.level", "debug")
+
+            forceExit = false
+
+            mods.register("computercraft") { source(sourceSets.main.get()) }
+        }
+
+        val client by registering {
+            workingDirectory(file("run"))
+        }
+
+        val server by registering {
+            workingDirectory(file("run/server"))
+            arg("--nogui")
+        }
+
+        val data by registering {
+            workingDirectory(file("run"))
+            args(
+                "--mod",
+                "computercraft",
+                "--all",
+                "--output",
+                file("src/generated/resources/"),
+                "--existing",
+                file("src/main/resources/"),
+            )
+            property("cct.pretty-json", "true")
+        }
+
+        fun RunConfig.configureForGameTest() {
+            val old = lazyTokens.get("minecraft_classpath")
+            lazyToken("minecraft_classpath") {
+                // We do some terrible hacks here to basically find all things not already on the runtime classpath
+                // and add them. /Except/ for our source sets, as those need to load inside the Minecraft classpath.
+                val testMod = configurations["testModRuntimeClasspath"].resolve()
+                val implementation = configurations.runtimeClasspath.get().resolve()
+                val new = (testMod - implementation)
+                    .asSequence()
+                    .filter { it.isFile && !it.name.endsWith("-test-fixtures.jar") }
+                    .map { it.absolutePath }
+                    .joinToString(File.pathSeparator)
+                if (old == null) new else old.get() + File.pathSeparator + new
+            }
+
+            property("cctest.sources", file("src/testMod/resources/data/cctest").absolutePath)
+
+            arg("--mixin.config=computercraft-gametest.mixins.json")
+
+            mods.register("cctest") {
+                source(sourceSets["testMod"])
+                source(sourceSets["testFixtures"])
+            }
+        }
+
+        val testClient by registering {
+            workingDirectory(file("run/testClient"))
+            parent(client.get())
+            configureForGameTest()
+        }
+
+        val gameTestServer by registering {
+            workingDirectory(file("run/testServer"))
+            configureForGameTest()
+
+            property("forge.logging.console.level", "info")
+        }
+    }
+
+    mappings("parchment", "${libs.versions.parchmentMc.get()}-${libs.versions.parchment.get()}-$mcVersion")
+
+    accessTransformer(file("src/main/resources/META-INF/accesstransformer.cfg"))
+}
+
+mixin {
+    add(sourceSets.main.get(), "computercraft.mixins.refmap.json")
+    config("computercraft.mixins.json")
+}
+
+reobf {
+    register("shadowJar")
+}
+
+configurations {
+    val shade by registering { isTransitive = false }
+    implementation { extendsFrom(shade.get()) }
+    register("cctJavadoc")
+}
+
+dependencies {
+    minecraft("net.minecraftforge:forge:$mcVersion-${libs.versions.forge.get()}")
+    annotationProcessor("org.spongepowered:mixin:0.8.5:processor")
+
+    compileOnly(libs.jetbrainsAnnotations)
+    annotationProcessorEverywhere(libs.autoService)
+
+    "extraModsCompileOnly"(fg.deobf("mezz.jei:jei-1.19.2-forge-api:11.3.0.262"))
+    "extraModsCompileOnly"(fg.deobf("mezz.jei:jei-1.19.2-common-api:11.3.0.262"))
+    "extraModsRuntimeOnly"(fg.deobf("mezz.jei:jei-1.19.2-forge:11.3.0.262"))
+    "extraModsCompileOnly"(fg.deobf("maven.modrinth:oculus:1.2.5"))
+
+    "shade"(libs.cobalt)
+    "shade"("io.netty:netty-codec-http:4.1.76.Final")
+
+    testFixturesApi(libs.bundles.test)
+    testFixturesApi(libs.bundles.kotlin)
+
+    testImplementation(libs.bundles.test)
+    testImplementation(libs.bundles.kotlin)
+    testRuntimeOnly(libs.bundles.testRuntime)
+
+    "cctJavadoc"(libs.cctJavadoc)
+}
+
+illuaminate {
+    version.set(libs.versions.illuaminate)
+}
+
+// Compile tasks
+
+tasks.javadoc {
+    include("dan200/computercraft/api/**/*.java")
+    (options as StandardJavadocDocletOptions).links("https://docs.oracle.com/en/java/javase/17/docs/api/")
+}
+
+val apiJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("api")
+    from(sourceSets.main.get().output) {
+        include("dan200/computercraft/api/**/*")
+    }
+}
+
+tasks.assemble { dependsOn(apiJar) }
+
+val luaJavadoc by tasks.registering(Javadoc::class) {
+    description = "Generates documentation for Java-side Lua functions."
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+
+    source(sourceSets.main.get().java)
+    setDestinationDir(buildDir.resolve("docs/luaJavadoc"))
+    classpath = sourceSets.main.get().compileClasspath
+
+    options.docletpath = configurations["cctJavadoc"].files.toList()
+    options.doclet = "cc.tweaked.javadoc.LuaDoclet"
+    (options as StandardJavadocDocletOptions).noTimestamp(false)
+
+    javadocTool.set(
+        javaToolchains.javadocToolFor {
+            languageVersion.set(cc.tweaked.gradle.CCTweakedPlugin.JAVA_VERSION)
+        },
+    )
+}
+
+tasks.processResources {
+    inputs.property("modVersion", modVersion)
+    inputs.property("forgeVersion", libs.versions.forge.get())
+    inputs.property("gitHash", cct.gitHash)
+
+    filesMatching("data/computercraft/lua/rom/help/credits.md") {
+        expand(mapOf("gitContributors" to cct.gitContributors.get().joinToString("\n")))
+    }
+
+    filesMatching("META-INF/mods.toml") {
+        expand(mapOf("forgeVersion" to libs.versions.forge.get(), "file" to mapOf("jarVersion" to modVersion)))
+    }
+}
+
+tasks.jar {
+    isReproducibleFileOrder = true
+    isPreserveFileTimestamps = false
+    finalizedBy("reobfJar")
+    archiveClassifier.set("slim")
+
+    manifest {
+        attributes(
+            "Specification-Title" to "computercraft",
+            "Specification-Vendor" to "SquidDev",
+            "Specification-Version" to "1",
+            "Implementation-Title" to "cctweaked",
+            "Implementation-Version" to modVersion,
+            "Implementation-Vendor" to "SquidDev",
+        )
+    }
+}
+
+tasks.shadowJar {
+    finalizedBy("reobfShadowJar")
+
+    archiveClassifier.set("")
+    configurations = listOf(project.configurations["shade"])
+    relocate("org.squiddev.cobalt", "cc.tweaked.internal.cobalt")
+    minimize()
+}
+
+tasks.assemble { dependsOn("shadowJar") }
+
+// Web tasks
+
+val rollup by tasks.registering(NpxExecToDir::class) {
+    group = LifecycleBasePlugin.BUILD_GROUP
+    description = "Bundles JS into rollup"
+
+    // Sources
+    inputs.files(fileTree("src/web")).withPropertyName("sources")
+    // Config files
+    inputs.file("tsconfig.json").withPropertyName("Typescript config")
+    inputs.file("rollup.config.js").withPropertyName("Rollup config")
+
+    // Output directory. Also defined in illuaminate.sexp and rollup.config.js
+    output.set(buildDir.resolve("rollup"))
+
+    args = listOf("rollup", "--config", "rollup.config.js")
+}
+
+val illuaminateDocs by tasks.registering(IlluaminateExecToDir::class) {
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+    description = "Generates docs using Illuaminate"
+
+    // Config files
+    inputs.file("illuaminate.sexp").withPropertyName("illuaminate.sexp")
+    // Sources
+    inputs.files(fileTree("doc")).withPropertyName("docs")
+    inputs.files(fileTree("src/main/resources/data/computercraft/lua")).withPropertyName("lua rom")
+    inputs.files(luaJavadoc)
+    // Additional assets
+    inputs.files(rollup)
+    inputs.file("src/web/styles.css").withPropertyName("styles")
+
+    // Output directory. Also defined in illuaminate.sexp and transform.tsx
+    output.set(buildDir.resolve("illuaminate"))
+
+    args = listOf("doc-gen")
+}
+
+val jsxDocs by tasks.registering(NpxExecToDir::class) {
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+    description = "Post-processes documentation to statically render some dynamic content."
+
+    // Config files
+    inputs.file("tsconfig.json").withPropertyName("Typescript config")
+    // Sources
+    inputs.files(fileTree("src/web")).withPropertyName("sources")
+    inputs.file("src/generated/export/index.json").withPropertyName("export")
+    inputs.files(illuaminateDocs)
+
+    // Output directory. Also defined in src/web/transform.tsx
+    output.set(buildDir.resolve("jsxDocs"))
+
+    args = listOf("ts-node", "-T", "--esm", "src/web/transform.tsx")
+}
+
+val docWebsite by tasks.registering(Copy::class) {
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+    description = "Assemble docs and assets together into the documentation website."
+
+    from(jsxDocs)
+
+    from("doc") {
+        include("logo.png")
+        include("images/**")
+    }
+    from(rollup) { exclude("index.js") }
+    from(illuaminateDocs) { exclude("**/*.html") }
+    from("src/generated/export/items") { into("images/items") }
+
+    into(buildDir.resolve("docs/site"))
+}
+
+// Check tasks
+
+tasks.test {
+    systemProperty("cct.test-files", buildDir.resolve("tmp/testFiles").absolutePath)
+}
+
+val lintLua by tasks.registering(IlluaminateExec::class) {
+    group = JavaBasePlugin.VERIFICATION_GROUP
+    description = "Lint Lua (and Lua docs) with illuaminate"
+
+    // Config files
+    inputs.file("illuaminate.sexp").withPropertyName("illuaminate.sexp")
+    // Sources
+    inputs.files(fileTree("doc")).withPropertyName("docs")
+    inputs.files(fileTree("src/main/resources/data/computercraft/lua")).withPropertyName("lua rom")
+    inputs.files(luaJavadoc)
+
+    args = listOf("lint")
+
+    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 runGametest by tasks.registering(JavaExec::class) {
+    group = LifecycleBasePlugin.VERIFICATION_GROUP
+    description = "Runs tests on a temporary Minecraft instance."
+    dependsOn("cleanRunGametest")
+
+    // Copy from runGameTestServer. We do it in this slightly odd way as runGameTestServer
+    // isn't created until the task is configured (which is no good for us).
+    val exec = tasks.getByName<JavaExec>("runGameTestServer")
+    dependsOn(exec.dependsOn)
+    exec.copyToFull(this)
+}
+
+cct.jacoco(runGametest)
+
+tasks.check { dependsOn(runGametest) }
+
+// Upload tasks
+
+val checkChangelog by tasks.registering(CheckChangelog::class) {
+    version.set(modVersion)
+    whatsNew.set(file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md"))
+    changelog.set(file("src/main/resources/data/computercraft/lua/rom/help/changelog.md"))
+}
+
+tasks.check { dependsOn(checkChangelog) }
+
+val publishCurseForge by tasks.registering(TaskPublishCurseForge::class) {
+    group = PublishingPlugin.PUBLISH_TASK_GROUP
+    description = "Upload artifacts to CurseForge"
+
+    apiToken = findProperty("curseForgeApiKey") ?: ""
+    enabled = apiToken != ""
+
+    val mainFile = upload("282001", tasks.shadowJar.get().archiveFile)
+    dependsOn(tasks.shadowJar) // Ughr.
+    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"
+    mainFile.releaseType = if (isStable) "release" else "alpha"
+    mainFile.gameVersions.add(mcVersion)
+}
+
+tasks.publish { dependsOn(publishCurseForge) }
+
+modrinth {
+    token.set(findProperty("modrinthApiKey") as String? ?: "")
+    projectId.set("gu7yAYhd")
+    versionNumber.set("$mcVersion-$modVersion")
+    versionName.set(modVersion)
+    versionType.set(if (isStable) "release" else "alpha")
+    uploadFile.set(tasks.shadowJar as Any)
+    gameVersions.add(mcVersion)
+    changelog.set("Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion).")
+
+    syncBodyFrom.set(provider { file("doc/mod-page.md").readText() })
+}
+
+tasks.publish { dependsOn(tasks.modrinth) }
+
 githubRelease {
     token(findProperty("githubApiKey") as String? ?: "")
     owner.set("cc-tweaked")
@@ -23,30 +407,54 @@ githubRelease {
     releaseName.set("[$mcVersion] $modVersion")
     body.set(
         provider {
-            "## " + project(":core").file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
+            "## " + file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
                 .readLines()
                 .takeWhile { it != "Type \"help changelog\" to see the full version history." }
                 .joinToString("\n").trim()
         },
     )
-    prerelease.set(isUnstable)
+    prerelease.set(!isStable)
 }
 
 tasks.publish { dependsOn(tasks.githubRelease) }
 
-idea.project.settings.compiler.javac {
-    // We want ErrorProne to be present when compiling via IntelliJ, as it offers some helpful warnings
-    // and errors. Loop through our source sets and find the appropriate flags.
-    moduleJavacAdditionalOptions = subprojects
-        .asSequence()
-        .map { evaluationDependsOn(it.path) }
-        .flatMap { project ->
-            val sourceSets = project.extensions.findByType(SourceSetContainer::class) ?: return@flatMap sequenceOf()
-            sourceSets.asSequence().map { sourceSet ->
-                val name = "${idea.project.name}.${project.name}.${sourceSet.name}"
-                val compile = project.tasks.named(sourceSet.compileJavaTaskName, JavaCompile::class).get()
-                name to compile.options.allCompilerArgs.joinToString(" ") { if (it.contains(" ")) "\"$it\"" else it }
+publishing {
+    publications {
+        register<MavenPublication>("maven") {
+            artifactId = base.archivesName.get()
+            from(components["java"])
+            artifact(apiJar)
+            fg.component(this)
+
+            pom {
+                name.set("CC: Tweaked")
+                description.set("CC: Tweaked is a fork of ComputerCraft, adding programmable computers, turtles and more to Minecraft.")
+                url.set("https://github.com/cc-tweaked/CC-Tweaked")
+
+                scm {
+                    url.set("https://github.com/cc-tweaked/CC-Tweaked.git")
+                }
+
+                issueManagement {
+                    system.set("github")
+                    url.set("https://github.com/cc-tweaked/CC-Tweaked/issues")
+                }
+
+                licenses {
+                    license {
+                        name.set("ComputerCraft Public License, Version 1.0")
+                        url.set("https://github.com/cc-tweaked/CC-Tweaked/blob/HEAD/LICENSE")
+                    }
+                }
             }
         }
-        .toMap()
+    }
+
+    repositories {
+        maven("https://squiddev.cc/maven") {
+            name = "SquidDev"
+
+            credentials(PasswordCredentials::class)
+        }
+    }
 }

buildSrc/build.gradle.kts

@@ -3,51 +3,14 @@ plugins {
     `kotlin-dsl`
 }
 
-// Duplicated in settings.gradle.kts
 repositories {
     mavenCentral()
     gradlePluginPortal()
-
-    maven("https://maven.minecraftforge.net") {
-        name = "Forge"
-        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")
-        }
-    }
-
-    maven("https://maven.fabricmc.net/") {
-        name = "Fabric"
-        content {
-            includeGroup("net.fabricmc")
-        }
-    }
 }
 
 dependencies {
-    implementation(libs.errorProne.plugin)
     implementation(libs.kotlin.plugin)
     implementation(libs.spotless)
-
-    implementation(libs.fabric.loom)
-    implementation(libs.forgeGradle)
-    implementation(libs.librarian)
-    implementation(libs.quiltflower)
-    implementation(libs.vanillaGradle)
 }
 
 gradlePlugin {

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

@@ -1,66 +0,0 @@
-/** Default configuration for Fabric projects. */
-
-import cc.tweaked.gradle.CCTweakedExtension
-import cc.tweaked.gradle.CCTweakedPlugin
-import cc.tweaked.gradle.IdeaRunConfigurations
-import cc.tweaked.gradle.MinecraftConfigurations
-
-plugins {
-    `java-library`
-    id("fabric-loom")
-    id("io.github.juuxel.loom-quiltflower")
-    id("cc-tweaked.java-convention")
-}
-
-plugins.apply(CCTweakedPlugin::class.java)
-
-val mcVersion: String by extra
-
-repositories {
-    maven("https://maven.parchmentmc.org/") {
-        name = "Parchment"
-        content {
-            includeGroup("org.parchmentmc.data")
-        }
-    }
-}
-
-loom {
-    splitEnvironmentSourceSets()
-    splitModDependencies.set(true)
-}
-
-MinecraftConfigurations.setup(project)
-
-extensions.configure(CCTweakedExtension::class.java) {
-    linters(minecraft = true, loader = "fabric")
-}
-
-dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-
-    minecraft("com.mojang:minecraft:$mcVersion")
-    mappings(
-        loom.layered {
-            officialMojangMappings()
-            parchment(
-                project.dependencies.create(
-                    group = "org.parchmentmc.data",
-                    name = "parchment-${libs.findVersion("parchmentMc").get()}",
-                    version = libs.findVersion("parchment").get().toString(),
-                    ext = "zip",
-                ),
-            )
-        },
-    )
-
-    modImplementation(libs.findLibrary("fabric-loader").get())
-    modImplementation(libs.findLibrary("fabric-api").get())
-
-    // Depend on error prone annotations to silence a lot of compile warnings.
-    compileOnlyApi(libs.findLibrary("errorProne.annotations").get())
-}
-
-tasks.ideaSyncTask {
-    doLast { IdeaRunConfigurations(project).patch() }
-}

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

@@ -1,39 +0,0 @@
-/** Default configuration for Forge projects. */
-
-import cc.tweaked.gradle.CCTweakedExtension
-import cc.tweaked.gradle.CCTweakedPlugin
-import cc.tweaked.gradle.IdeaRunConfigurations
-import cc.tweaked.gradle.MinecraftConfigurations
-
-plugins {
-    id("cc-tweaked.java-convention")
-    id("net.minecraftforge.gradle")
-    id("org.parchmentmc.librarian.forgegradle")
-}
-
-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")
-
-    accessTransformer(project(":forge").file("src/main/resources/META-INF/accesstransformer.cfg"))
-}
-
-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.gametest.gradle.kts

@@ -1,5 +1,4 @@
-import cc.tweaked.gradle.clientClasses
-import cc.tweaked.gradle.commonClasses
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 /**
  * Sets up the configurations for writing game tests.
@@ -12,13 +11,12 @@ plugins {
     id("cc-tweaked.java-convention")
 }
 
-val main = sourceSets["main"]
-val client = sourceSets["client"]
+val main = sourceSets.main.get()
 
-// Both testMod and testFixtures inherit from the main and client classpath, just so we have access to Minecraft classes.
+// Both testMod and testFixtures inherit from the main classpath, just so we have access to Minecraft classes.
 val testMod by sourceSets.creating {
-    compileClasspath += main.compileClasspath + client.compileClasspath
-    runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
+    compileClasspath += main.compileClasspath
+    runtimeClasspath += main.runtimeClasspath
 }
 
 configurations {
@@ -34,13 +32,12 @@ configurations {
 // Like the main test configurations, we're safe to depend on source set outputs.
 dependencies {
     add(testMod.implementationConfigurationName, main.output)
-    add(testMod.implementationConfigurationName, client.output)
 }
 
 // Similar to java-test-fixtures, but tries to avoid putting the obfuscated jar on the classpath.
 
 val testFixtures by sourceSets.creating {
-    compileClasspath += main.compileClasspath + client.compileClasspath
+    compileClasspath += main.compileClasspath
 }
 
 java.registerFeature("testFixtures") {
@@ -49,12 +46,8 @@ java.registerFeature("testFixtures") {
 }
 
 dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    add(testFixtures.apiConfigurationName, libs.findBundle("test").get())
-    // Consumers of this project already have the common and client classes on the classpath, so it's fine for these
-    // to be compile-only.
-    add(testFixtures.compileOnlyApiConfigurationName, commonClasses(project))
-    add(testFixtures.compileOnlyApiConfigurationName, clientClasses(project))
+    add(testFixtures.implementationConfigurationName, main.output)
 
     testImplementation(testFixtures(project))
+    add(testMod.implementationConfigurationName, testFixtures(project))
 }

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

@@ -1,35 +1,23 @@
-import cc.tweaked.gradle.CCTweakedExtension
 import cc.tweaked.gradle.CCTweakedPlugin
 import cc.tweaked.gradle.LicenseHeader
 import com.diffplug.gradle.spotless.FormatExtension
 import com.diffplug.spotless.LineEnding
-import net.ltgt.gradle.errorprone.CheckSeverity
-import net.ltgt.gradle.errorprone.errorprone
 import java.nio.charset.StandardCharsets
 
 plugins {
     `java-library`
-    idea
     jacoco
     checkstyle
     id("com.diffplug.spotless")
-    id("net.ltgt.errorprone")
 }
 
-val modVersion: String by extra
-val mcVersion: String by extra
-
-group = "cc.tweaked"
-version = modVersion
-
-base.archivesName.convention("cc-tweaked-$mcVersion-${project.name}")
-
 java {
     toolchain {
         languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
     }
 
     withSourcesJar()
+    withJavadocJar()
 }
 
 repositories {
@@ -40,15 +28,10 @@ repositories {
             includeGroup("org.squiddev")
             includeGroup("cc.tweaked")
             // Things we mirror
-            includeGroup("dev.architectury")
+            includeGroup("com.blamejared.crafttweaker")
+            includeGroup("commoble.morered")
             includeGroup("maven.modrinth")
-            includeGroup("me.shedaniel")
-            includeGroup("me.shedaniel.cloth")
             includeGroup("mezz.jei")
-            includeModule("com.terraformersmc", "modmenu")
-            includeModule("fuzs.forgeconfigapiport", "forgeconfigapiport-fabric")
-            // Until https://github.com/SpongePowered/Mixin/pull/593 is merged
-            includeModule("org.spongepowered", "mixin")
         }
     }
 }
@@ -56,9 +39,6 @@ repositories {
 dependencies {
     val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
     checkstyle(libs.findLibrary("checkstyle").get())
-
-    errorprone(libs.findLibrary("errorProne-core").get())
-    errorprone(libs.findLibrary("nullAway").get())
 }
 
 // Configure default JavaCompile tasks with our arguments.
@@ -66,68 +46,13 @@ 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.errorprone {
-            check("InvalidBlockTag", CheckSeverity.OFF) // Broken by @cc.xyz
-            check("InvalidParam", CheckSeverity.OFF) // Broken by records.
-            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("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
-
-            check("NullAway", CheckSeverity.ERROR)
-            option("NullAway:AnnotatedPackages", listOf("dan200.computercraft", "net.fabricmc.fabric.api").joinToString(","))
-            option("NullAway:ExcludedFieldAnnotations", listOf("org.spongepowered.asm.mixin.Shadow").joinToString(","))
-            option("NullAway:CastToNonNullMethod", "dan200.computercraft.core.util.Nullability.assertNonNull")
-            option("NullAway:CheckOptionalEmptiness")
-            option("NullAway:AcknowledgeRestrictiveAnnotations")
-        }
     }
 }
 
-tasks.compileTestJava {
-    options.errorprone {
-        check("NullAway", CheckSeverity.OFF)
-    }
-}
-
-
 tasks.withType(JavaCompile::class.java).configureEach {
     options.encoding = "UTF-8"
 }
 
-tasks.withType(AbstractArchiveTask::class.java).configureEach {
-    isPreserveFileTimestamps = false
-    isReproducibleFileOrder = true
-    dirMode = Integer.valueOf("755", 8)
-    fileMode = Integer.valueOf("664", 8)
-}
-
-tasks.jar {
-    manifest {
-        attributes(
-            "Specification-Title" to "computercraft",
-            "Specification-Vendor" to "SquidDev",
-            "Specification-Version" to "1",
-            "Implementation-Title" to "cctweaked-${project.name}",
-            "Implementation-Version" to modVersion,
-            "Implementation-Vendor" to "SquidDev",
-        )
-    }
-}
-
-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/")
-    }
-}
-
 tasks.test {
     finalizedBy("jacocoTestReport")
 
@@ -142,14 +67,6 @@ tasks.withType(JacocoReport::class.java).configureEach {
     reports.html.required.set(true)
 }
 
-project.plugins.withType(CCTweakedPlugin::class.java) {
-    // Set up jacoco to read from /all/ our source directories.
-    val cct = project.extensions.getByType<CCTweakedExtension>()
-    project.tasks.named("jacocoTestReport", JacocoReport::class.java) {
-        for (ref in cct.sourceSets.get()) sourceDirectories.from(ref.allSource.sourceDirectories)
-    }
-}
-
 spotless {
     encoding = StandardCharsets.UTF_8
     lineEndings = LineEnding.UNIX
@@ -161,8 +78,8 @@ spotless {
     }
 
     val licenser = LicenseHeader.create(
-        api = rootProject.file("config/license/api.txt"),
-        main = rootProject.file("config/license/main.txt"),
+        api = file("config/license/api.txt"),
+        main = file("config/license/main.txt"),
     )
 
     java {
@@ -187,12 +104,3 @@ spotless {
         ktlint().editorConfigOverride(ktlintConfig)
     }
 }
-
-idea.module {
-    excludeDirs.addAll(project.files("run", "out", "logs").files)
-
-    // Force Gradle to write to inherit the output directory from the parent, instead of writing to out/xxx/classes.
-    // This is required for Loom, and we patch Forge's run configurations to work there.
-    // TODO: Submit a patch to Forge to support ProjectRootManager.
-    inheritOutputDirs = true
-}

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

@@ -1,45 +0,0 @@
-import org.gradle.kotlin.dsl.`maven-publish`
-
-plugins {
-    `java-library`
-    `maven-publish`
-}
-
-publishing {
-    publications {
-        register<MavenPublication>("maven") {
-            artifactId = base.archivesName.get()
-            from(components["java"])
-
-            pom {
-                name.set("CC: Tweaked")
-                description.set("CC: Tweaked is a fork of ComputerCraft, adding programmable computers, turtles and more to Minecraft.")
-                url.set("https://github.com/cc-tweaked/CC-Tweaked")
-
-                scm {
-                    url.set("https://github.com/cc-tweaked/CC-Tweaked.git")
-                }
-
-                issueManagement {
-                    system.set("github")
-                    url.set("https://github.com/cc-tweaked/CC-Tweaked/issues")
-                }
-
-                licenses {
-                    license {
-                        name.set("ComputerCraft Public License, Version 1.0")
-                        url.set("https://github.com/cc-tweaked/CC-Tweaked/blob/HEAD/LICENSE")
-                    }
-                }
-            }
-        }
-    }
-
-    repositories {
-        maven("https://squiddev.cc/maven") {
-            name = "SquidDev"
-
-            credentials(PasswordCredentials::class)
-        }
-    }
-}

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

@@ -1,31 +0,0 @@
-/** Default configuration for non-modloader-specific Minecraft projects. */
-
-import cc.tweaked.gradle.CCTweakedExtension
-import cc.tweaked.gradle.CCTweakedPlugin
-import cc.tweaked.gradle.MinecraftConfigurations
-
-plugins {
-    id("cc-tweaked.java-convention")
-    id("org.spongepowered.gradle.vanilla")
-}
-
-plugins.apply(CCTweakedPlugin::class.java)
-
-val mcVersion: String by extra
-
-minecraft {
-    version(mcVersion)
-}
-
-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())
-}
-
-MinecraftConfigurations.setup(project)
-
-extensions.configure(CCTweakedExtension::class.java) {
-    linters(minecraft = true, loader = null)
-}

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

@@ -1,35 +1,23 @@
 package cc.tweaked.gradle
 
-import net.ltgt.gradle.errorprone.CheckSeverity
-import net.ltgt.gradle.errorprone.errorprone
-import org.gradle.api.GradleException
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
-import org.gradle.api.Task
 import org.gradle.api.attributes.TestSuiteType
 import org.gradle.api.file.FileSystemOperations
-import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.provider.Provider
-import org.gradle.api.provider.SetProperty
 import org.gradle.api.reporting.ReportingExtension
-import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.compile.JavaCompile
-import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.api.tasks.JavaExec
+import org.gradle.api.tasks.SourceSetContainer
 import org.gradle.configurationcache.extensions.capitalized
+import org.gradle.kotlin.dsl.get
 import org.gradle.language.base.plugins.LifecycleBasePlugin
-import org.gradle.language.jvm.tasks.ProcessResources
-import org.gradle.process.JavaForkOptions
 import org.gradle.testing.jacoco.plugins.JacocoCoverageReport
 import org.gradle.testing.jacoco.plugins.JacocoPluginExtension
 import org.gradle.testing.jacoco.plugins.JacocoTaskExtension
 import org.gradle.testing.jacoco.tasks.JacocoReport
-import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.io.File
+import java.io.BufferedWriter
 import java.io.IOException
-import java.net.URI
-import java.net.URL
+import java.io.OutputStreamWriter
 import java.util.regex.Pattern
 
 abstract class CCTweakedExtension(
@@ -38,137 +26,45 @@ abstract class CCTweakedExtension(
 ) {
     /** Get the hash of the latest git commit. */
     val gitHash: Provider<String> = gitProvider(project, "<no git hash>") {
-        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "HEAD").trim()
+        ProcessHelpers.captureOut("git", "-C", project.projectDir.absolutePath, "rev-parse", "HEAD").trim()
     }
 
     /** Get the current git branch. */
     val gitBranch: Provider<String> = gitProvider(project, "<no git branch>") {
-        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "--abbrev-ref", "HEAD")
-            .trim()
+        ProcessHelpers.captureOut("git", "-C", project.projectDir.absolutePath, "rev-parse", "--abbrev-ref", "HEAD").trim()
     }
 
     /** Get a list of all contributors to the project. */
     val gitContributors: Provider<List<String>> = gitProvider(project, listOf()) {
-        ProcessHelpers.captureLines(
-            "git", "-C", project.rootProject.projectDir.absolutePath, "shortlog", "-ns",
-            "--group=author", "--group=trailer:co-authored-by", "HEAD",
+        val authors: Set<String> = HashSet(
+            ProcessHelpers.captureLines(
+                "git", "-C", project.projectDir.absolutePath, "log",
+                "--format=tformat:%an <%ae>%n%cn <%ce>%n%(trailers:key=Co-authored-by,valueonly)",
+            ),
         )
-            .asSequence()
-            .map {
-                val matcher = COMMIT_COUNTS.matcher(it)
-                matcher.find()
-                matcher.group(1)
-            }
-            .filter { !IGNORED_USERS.contains(it) }
-            .toList()
-            .sortedWith(String.CASE_INSENSITIVE_ORDER)
-    }
+        val process = ProcessHelpers.startProcess("git", "check-mailmap", "--stdin")
+        BufferedWriter(OutputStreamWriter(process.outputStream)).use { writer ->
+            for (authorName in authors) {
+                var author = authorName
 
-    /**
-     * References to other sources
-     */
-    val sourceDirectories: SetProperty<SourceSetReference> = project.objects.setProperty(SourceSetReference::class.java)
-
-    /** All source sets referenced by this project. */
-    val sourceSets = sourceDirectories.map { x -> x.map { it.sourceSet } }
-
-    init {
-        sourceDirectories.finalizeValueOnRead()
-        project.afterEvaluate { sourceDirectories.disallowChanges() }
-    }
-
-    /**
-     * Mark this project as consuming another project. Its [sourceDirectories] are added, allowing easier configuration
-     * of run configurations and other tasks which consume sources/classes.
-     */
-    fun externalSources(project: Project) {
-        val otherCct = project.extensions.getByType(CCTweakedExtension::class.java)
-        for (sourceSet in otherCct.sourceDirectories.get()) {
-            sourceDirectories.add(SourceSetReference(sourceSet.sourceSet, classes = sourceSet.classes, external = true))
-        }
-    }
-
-    /**
-     * Add a dependency on another project such that its sources and compiles are processed with this one.
-     *
-     * This is used when importing a common library into a loader-specific one, as we want to compile sources using
-     * the loader-specific sources.
-     */
-    fun inlineProject(path: String) {
-        val otherProject = project.evaluationDependsOn(path)
-        val otherJava = otherProject.extensions.getByType(JavaPluginExtension::class.java)
-        val main = otherJava.sourceSets.getByName("main")
-        val client = otherJava.sourceSets.getByName("client")
-        val testMod = otherJava.sourceSets.findByName("testMod")
-        val testFixtures = otherJava.sourceSets.findByName("testFixtures")
-
-        // Pull in sources from the other project.
-        extendSourceSet(otherProject, main)
-        extendSourceSet(otherProject, client)
-        if (testMod != null) extendSourceSet(otherProject, testMod)
-        if (testFixtures != null) extendSourceSet(otherProject, testFixtures)
-
-        // The extra source-processing tasks should include these files too.
-        project.tasks.named(main.javadocTaskName, Javadoc::class.java) { source(main.allJava, client.allJava) }
-        project.tasks.named(main.sourcesJarTaskName, Jar::class.java) { from(main.allSource, client.allSource) }
-        sourceDirectories.addAll(SourceSetReference.inline(main), SourceSetReference.inline(client))
-    }
-
-    /**
-     * Extend a source set with files from another project.
-     *
-     * This actually extends the original compile tasks, as extending the source sets does not play well with IDEs.
-     */
-    private fun extendSourceSet(otherProject: Project, sourceSet: SourceSet) {
-        project.tasks.named(sourceSet.compileJavaTaskName, JavaCompile::class.java) {
-            dependsOn(otherProject.tasks.named(sourceSet.compileJavaTaskName)) // Avoid duplicate compile errors
-            source(sourceSet.allJava)
-        }
-
-        project.tasks.named(sourceSet.processResourcesTaskName, ProcessResources::class.java) {
-            from(sourceSet.resources)
-        }
-
-        // Also try to depend on Kotlin if it exists
-        val kotlin = otherProject.extensions.findByType(KotlinProjectExtension::class.java)
-        if (kotlin != null) {
-            val compileKotlin = sourceSet.getCompileTaskName("kotlin")
-            project.tasks.named(compileKotlin, KotlinCompile::class.java) {
-                dependsOn(otherProject.tasks.named(compileKotlin))
-                source(kotlin.sourceSets.getByName(sourceSet.name).kotlin)
+                if (author.isEmpty()) continue
+                if (!author.endsWith(">")) author += ">" // Some commits have broken Co-Authored-By lines!
+                writer.write(author)
+                writer.newLine()
             }
         }
-
-        // If we're doing an IDE sync, add a fake dependency to ensure it's on the classpath.
-        if (isIdeSync) project.dependencies.add(sourceSet.apiConfigurationName, sourceSet.output)
-    }
-
-    fun linters(@Suppress("UNUSED_PARAMETER") vararg unused: UseNamedArgs, minecraft: Boolean, loader: String?) {
-        val java = project.extensions.getByType(JavaPluginExtension::class.java)
-        val sourceSets = java.sourceSets
-
-        project.dependencies.run { add("errorprone", project(mapOf("path" to ":lints"))) }
-        sourceSets.all {
-            val name = name
-            project.tasks.named(compileJavaTaskName, JavaCompile::class.java) {
-                options.errorprone {
-                    // Only the main source set should run the side checker
-                    check("SideChecker", if (minecraft && name == "main") CheckSeverity.DEFAULT else CheckSeverity.OFF)
-
-                    // The MissingLoaderOverride check superseeds the MissingOverride one, so disable that.
-                    if (loader != null) {
-                        check("MissingOverride", CheckSeverity.OFF)
-                        option("ModLoader", loader)
-                    } else {
-                        check("LoaderOverride", CheckSeverity.OFF)
-                        check("MissingLoaderOverride", CheckSeverity.OFF)
-                    }
-                }
-            }
+        val contributors: MutableSet<String> = HashSet()
+        for (authorLine in ProcessHelpers.captureLines(process)) {
+            val matcher = EMAIL.matcher(authorLine)
+            matcher.find()
+            val name = matcher.group(1)
+            if (!IGNORED_USERS.contains(name)) contributors.add(name)
         }
+
+        contributors.sortedWith(String.CASE_INSENSITIVE_ORDER)
     }
 
-    fun <T> jacoco(task: NamedDomainObjectProvider<T>) where T : Task, T : JavaForkOptions {
+    fun jacoco(task: NamedDomainObjectProvider<JavaExec>) {
         val classDump = project.buildDir.resolve("jacocoClassDump/${task.name}")
         val reportTaskName = "jacoco${task.name.capitalized()}Report"
 
@@ -197,7 +93,8 @@ abstract class CCTweakedExtension(
             classDirectories.from(classDump)
 
             // Don't want to use sourceSets(...) here as we have a custom class directory.
-            for (ref in sourceSets.get()) sourceDirectories.from(ref.allSource.sourceDirectories)
+            val sourceSets = project.extensions.getByType(SourceSetContainer::class.java)
+            sourceDirectories.from(sourceSets["main"].allSource.sourceDirectories)
         }
 
         project.extensions.configure(ReportingExtension::class.java) {
@@ -207,43 +104,8 @@ abstract class CCTweakedExtension(
         }
     }
 
-    /**
-     * Download a file by creating a dummy Ivy repository.
-     *
-     * This should only be used for one-off downloads. Using a more conventional Ivy or Maven repository is preferred
-     * where possible.
-     */
-    fun downloadFile(label: String, url: String): File {
-        val url = URL(url)
-        val path = File(url.path)
-
-        project.repositories.ivy {
-            name = label
-            setUrl(URI(url.protocol, url.userInfo, url.host, url.port, path.parent, null, null))
-            patternLayout {
-                artifact("[artifact].[ext]")
-            }
-            metadataSources {
-                artifact()
-            }
-            content {
-                includeModule("cc.tweaked.internal", path.nameWithoutExtension)
-            }
-        }
-
-        return project.configurations.detachedConfiguration(
-            project.dependencies.create(
-                mapOf(
-                    "group" to "cc.tweaked.internal",
-                    "name" to path.nameWithoutExtension,
-                    "ext" to path.extension,
-                ),
-            ),
-        ).resolve().single()
-    }
-
     companion object {
-        private val COMMIT_COUNTS = Pattern.compile("""^\s*[0-9]+\s+(.*)$""")
+        private val EMAIL = Pattern.compile("^([^<]+) <.+>$")
         private val IGNORED_USERS = setOf(
             "GitHub", "Daniel Ratcliffe", "Weblate",
         )
@@ -255,14 +117,8 @@ abstract class CCTweakedExtension(
                 } catch (e: IOException) {
                     project.logger.error("Cannot read Git repository: ${e.message}")
                     default
-                } catch (e: GradleException) {
-                    project.logger.error("Cannot read Git repository: ${e.message}")
-                    default
                 }
             }
         }
-
-        private val isIdeSync: Boolean
-            get() = java.lang.Boolean.parseBoolean(System.getProperty("idea.sync.active", "false"))
     }
 }

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

@@ -2,8 +2,6 @@ package cc.tweaked.gradle
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.jvm.toolchain.JavaLanguageVersion
 
 /**
@@ -11,12 +9,7 @@ import org.gradle.jvm.toolchain.JavaLanguageVersion
  */
 class CCTweakedPlugin : Plugin<Project> {
     override fun apply(project: Project) {
-        val cct = project.extensions.create("cct", CCTweakedExtension::class.java)
-
-        project.plugins.withType(JavaPlugin::class.java) {
-            val sourceSets = project.extensions.getByType(JavaPluginExtension::class.java).sourceSets
-            cct.sourceDirectories.add(SourceSetReference.internal(sourceSets.getByName("main")))
-        }
+        project.extensions.create("cct", CCTweakedExtension::class.java)
     }
 
     companion object {

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

@@ -6,6 +6,7 @@ import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 import org.gradle.language.base.plugins.LifecycleBasePlugin
+import java.nio.charset.StandardCharsets
 
 /**
  * Checks the `changelog.md` and `whatsnew.md` files are well-formed.

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

@@ -5,6 +5,7 @@ import com.diffplug.spotless.FormatterStep
 import com.diffplug.spotless.generic.LicenseHeaderStep
 import java.io.File
 import java.io.Serializable
+import java.nio.charset.StandardCharsets
 
 /**
  * Similar to [LicenseHeaderStep], but supports multiple licenses.

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

@@ -2,116 +2,19 @@ package cc.tweaked.gradle
 
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.tasks.JavaExec
-import org.gradle.process.BaseExecSpec
-import org.gradle.process.JavaExecSpec
-import org.gradle.process.ProcessForkOptions
 
-/**
- * Add an annotation processor to all source sets.
- */
 fun DependencyHandler.annotationProcessorEverywhere(dep: Any) {
     add("compileOnly", dep)
     add("annotationProcessor", dep)
 
-    add("clientCompileOnly", dep)
-    add("clientAnnotationProcessor", dep)
-
     add("testCompileOnly", dep)
     add("testAnnotationProcessor", dep)
 }
 
-/**
- * A version of [JavaExecSpec.copyTo] which copies *all* properties.
- */
 fun JavaExec.copyToFull(spec: JavaExec) {
     copyTo(spec)
-
-    // Additional Java options
-    spec.jvmArgs = jvmArgs // Fabric overrides getJvmArgs so copyTo doesn't do the right thing.
-    spec.args = args
-    spec.argumentProviders.addAll(argumentProviders)
-    spec.mainClass.set(mainClass)
     spec.classpath = classpath
+    spec.mainClass.set(mainClass)
     spec.javaLauncher.set(javaLauncher)
-    if (executable != null) spec.setExecutable(executable!!)
-
-    // Additional ExecSpec options
-    copyToExec(spec)
-}
-
-/**
- * Copy additional [BaseExecSpec] options which aren't handled by [ProcessForkOptions.copyTo].
- */
-fun BaseExecSpec.copyToExec(spec: BaseExecSpec) {
-    spec.isIgnoreExitValue = isIgnoreExitValue
-    if (standardInput != null) spec.standardInput = standardInput
-    if (standardOutput != null) spec.standardOutput = standardOutput
-    if (errorOutput != null) spec.errorOutput = errorOutput
-}
-
-/**
- * An alternative to [Nothing] with a more descriptive name. Use to enforce calling a function with named arguments:
- *
- * ```kotlin
- * fun f(vararg unused: UseNamedArgs, arg1: Int, arg2: Int) {
- *   // ...
- * }
- * ```
- */
-class UseNamedArgs private constructor()
-
-/**
- * An [AutoCloseable] implementation which can be used to combine other [AutoCloseable] instances.
- *
- * Values which implement [AutoCloseable] can be dynamically registered with [CloseScope.add]. When the scope is closed,
- * each value is closed in the opposite order.
- *
- * This is largely intended for cases where it's not appropriate to nest [AutoCloseable.use], for instance when nested
- * would be too deep.
- */
-class CloseScope : AutoCloseable {
-    private val toClose = ArrayDeque<AutoCloseable>()
-
-    /**
-     * Add a value to be closed when this scope is closed.
-     */
-    public fun add(value: AutoCloseable) {
-        toClose.addLast(value)
-    }
-
-    override fun close() {
-        close(null)
-    }
-
-    @PublishedApi
-    internal fun close(baseException: Throwable?) {
-        var exception = baseException
-
-        while (true) {
-            var toClose = toClose.removeLastOrNull() ?: break
-            try {
-                toClose.close()
-            } catch (e: Throwable) {
-                if (exception == null) {
-                    exception = e
-                } else {
-                    exception.addSuppressed(e)
-                }
-            }
-        }
-
-        if (exception != null) throw exception
-    }
-
-    inline fun <R> use(block: (CloseScope) -> R): R {
-        var exception: Throwable? = null
-        try {
-            return block(this)
-        } catch (e: Throwable) {
-            exception = e
-            throw e
-        } finally {
-            close(exception)
-        }
-    }
+    spec.args = args
 }

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

@@ -1,170 +0,0 @@
-package cc.tweaked.gradle
-
-import org.gradle.api.Project
-import org.gradle.api.logging.Logging
-import org.w3c.dom.Attr
-import org.w3c.dom.Document
-import org.w3c.dom.Node
-import org.xml.sax.InputSource
-import java.nio.file.Files
-import java.nio.file.Path
-import javax.xml.parsers.DocumentBuilderFactory
-import javax.xml.transform.TransformerFactory
-import javax.xml.transform.dom.DOMSource
-import javax.xml.transform.stream.StreamResult
-import javax.xml.xpath.XPathConstants
-import javax.xml.xpath.XPathFactory
-
-/**
- * Patches up run configurations from ForgeGradle and Loom.
- *
- * Would be good to PR some (or all) of these changes upstream at some point.
- *
- * @see net.fabricmc.loom.configuration.ide.idea.IdeaSyncTask
- * @see net.minecraftforge.gradle.common.util.runs.IntellijRunGenerator
- */
-internal class IdeaRunConfigurations(project: Project) {
-    private val rootProject = project.rootProject
-
-    private val documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder()
-    private val xpath = XPathFactory.newInstance().newXPath()
-    private val writer = TransformerFactory.newInstance().newTransformer()
-
-    private val ideaDir = rootProject.file(".idea/")
-    private val buildDir: Lazy<String?> = lazy {
-        val ideaMisc = ideaDir.resolve("misc.xml")
-
-        try {
-            val doc = Files.newBufferedReader(ideaMisc.toPath()).use {
-                documentBuilder.parse(InputSource(it))
-            }
-            val node =
-                xpath.evaluate("//component[@name=\"ProjectRootManager\"]/output", doc, XPathConstants.NODE) as Node
-            val attr = node.attributes.getNamedItem("url") as Attr
-            attr.value.removePrefix("file://")
-        } catch (e: Exception) {
-            LOGGER.error("Failed to find root directory", e)
-            null
-        }
-    }
-
-    fun patch() = synchronized(LOCK) {
-        val runConfigDir = ideaDir.resolve("runConfigurations")
-        if (!runConfigDir.isDirectory) return
-
-        Files.list(runConfigDir.toPath()).use {
-            for (configuration in it) {
-                val filename = configuration.fileName.toString();
-                when {
-                    filename.endsWith("_fabric.xml") -> patchFabric(configuration)
-                    filename.startsWith("forge_") && filename.endsWith(".xml") -> patchForge(configuration)
-                    else -> {}
-                }
-            }
-        }
-    }
-
-    private fun patchFabric(path: Path) = withXml(path) {
-        setXml("//configuration", "folderName") { "Fabric" }
-    }
-
-    private fun patchForge(path: Path) = withXml(path) {
-        val configId = path.fileName.toString().removePrefix("forge_").removeSuffix(".xml")
-        val sourceSet = forgeConfigs[configId]
-        if (sourceSet == null) {
-            LOGGER.error("[{}] Cannot map run configuration to a known source set", path)
-            return@withXml
-        }
-
-        setXml("//configuration", "folderName") { "Forge" }
-        setXml("//configuration/module", "name") { "${rootProject.name}.forge.$sourceSet" }
-
-        if (buildDir.value == null) return@withXml
-        setXml("//configuration/envs/env[@name=\"MOD_CLASSES\"]", "value") { classpath ->
-            val classes = classpath!!.split(':')
-            val newClasses = mutableListOf<String>()
-            fun appendUnique(x: String) {
-                if (!newClasses.contains(x)) newClasses.add(x)
-            }
-
-            for (entry in classes) {
-                if (!entry.contains("/out/")) {
-                    appendUnique(entry)
-                    continue
-                }
-
-                val match = CLASSPATH_ENTRY.matchEntire(entry)
-                if (match != null) {
-                    val modId = match.groups["modId"]!!.value
-                    val proj = match.groups["proj"]!!.value
-                    var component = match.groups["component"]!!.value
-                    if (component == "production") component = "main"
-
-                    appendUnique(forgeModEntry(modId, proj, component))
-                } else {
-                    LOGGER.warn("[{}] Unknown classpath entry {}", path, entry)
-                    appendUnique(entry)
-                }
-            }
-
-            // Ensure common code is on the classpath
-            for (proj in listOf("common", "common-api")) {
-                for (component in listOf("main", "client")) {
-                    appendUnique(forgeModEntry("computercraft", proj, component))
-                }
-            }
-
-            if (newClasses.any { it.startsWith("cctest%%") }) {
-                appendUnique(forgeModEntry("cctest", "core", "testFixtures"))
-                appendUnique(forgeModEntry("cctest", "common", "testFixtures"))
-                appendUnique(forgeModEntry("cctest", "common", "testMod"))
-            }
-
-            newClasses.joinToString(":")
-        }
-    }
-
-    private fun forgeModEntry(mod: String, project: String, component: String) =
-        "$mod%%${buildDir.value}/production/${rootProject.name}.$project.$component"
-
-    private fun LocatedDocument.setXml(xpath: String, attribute: String, value: (String?) -> String) {
-        val node = this@IdeaRunConfigurations.xpath.evaluate(xpath, document, XPathConstants.NODE) as Node?
-        if (node == null) {
-            LOGGER.error("[{}] Cannot find {}", path.fileName, xpath)
-            return
-        }
-
-        val attr = node.attributes.getNamedItem(attribute) as Attr? ?: document.createAttribute(attribute)
-        val oldValue = attr.value
-        attr.value = value(attr.value)
-        node.attributes.setNamedItem(attr)
-
-        if (oldValue != attr.value) {
-            LOGGER.info("[{}] Setting {}@{}:\n  Old: {}\n  New: {}", path.fileName, xpath, attribute, oldValue, attr.value)
-        }
-    }
-
-    private fun withXml(path: Path, run: LocatedDocument.() -> Unit) {
-        val doc = Files.newBufferedReader(path).use { documentBuilder.parse(InputSource(it)) }
-        run(LocatedDocument(path, doc))
-        Files.newBufferedWriter(path).use { writer.transform(DOMSource(doc), StreamResult(it)) }
-    }
-
-    private class LocatedDocument(val path: Path, val document: Document)
-
-    companion object {
-        private val LOGGER = Logging.getLogger(IdeaRunConfigurations::class.java)
-        private val LOCK = Any()
-
-        private val CLASSPATH_ENTRY =
-            Regex("(?<modId>[a-z]+)%%\\\$PROJECT_DIR\\\$/projects/(?<proj>[a-z-]+)/out/(?<component>\\w+)/(?<type>[a-z]+)\$")
-
-        private val forgeConfigs = mapOf(
-            "runClient" to "client",
-            "runData" to "main",
-            "runGameTestServer" to "testMod",
-            "runServer" to "main",
-            "runTestClient" to "testMod",
-        )
-    }
-}

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

@@ -66,11 +66,9 @@ class IlluaminatePlugin : Plugin<Project> {
 
         val osArch = System.getProperty("os.arch").toLowerCase()
         val arch = when {
-            // On macOS the x86_64 binary will work for both ARM and Intel Macs through Rosetta.
-            os == "macos" -> "x86_64"
             osArch == "arm" || osArch.startsWith("aarch") -> error("Unsupported architecture '$osArch' for illuaminate")
             osArch.contains("64") -> "x86_64"
-            else -> error("Unsupported architecture '$osArch' for illuaminate")
+            else -> error("Unsupported architecture $osArch for illuaminate")
         }
 
         return project.dependencies.create(

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

@@ -1,62 +0,0 @@
-package cc.tweaked.gradle
-
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.artifacts.MinimalExternalModuleDependency
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.specs.Spec
-
-/**
- * A dependency in a POM file.
- */
-data class MavenDependency(val groupId: String?, val artifactId: String?, val version: String?, val scope: String?)
-
-/**
- * A spec specifying which dependencies to include/exclude.
- */
-class MavenDependencySpec {
-    private val excludeSpecs = mutableListOf<Spec<MavenDependency>>()
-
-    fun exclude(spec: Spec<MavenDependency>) {
-        excludeSpecs.add(spec)
-    }
-
-    fun exclude(dep: Dependency) {
-        exclude {
-            (dep.group.isNullOrEmpty() || dep.group == it.groupId) &&
-                (dep.name.isNullOrEmpty() || dep.name == it.artifactId) &&
-                (dep.version.isNullOrEmpty() || dep.version == it.version)
-        }
-    }
-
-    fun exclude(dep: MinimalExternalModuleDependency) {
-        exclude {
-            dep.module.group == it.groupId && dep.module.name == it.artifactId
-        }
-    }
-
-    fun isIncluded(dep: MavenDependency) = !excludeSpecs.any { it.isSatisfiedBy(dep) }
-}
-
-/**
- * Configure dependencies present in this publication's POM file.
- *
- * While this approach is very ugly, it's the easiest way to handle it!
- */
-fun MavenPublication.mavenDependencies(action: MavenDependencySpec.() -> Unit) {
-    val spec = MavenDependencySpec()
-    action(spec)
-
-    pom.withXml {
-        val dependencies = XmlUtil.findChild(asNode(), "dependencies") ?: return@withXml
-        dependencies.children().map { it as groovy.util.Node }.forEach {
-            val dep = MavenDependency(
-                groupId = XmlUtil.findChild(it, "groupId")?.text(),
-                artifactId = XmlUtil.findChild(it, "artifactId")?.text(),
-                version = XmlUtil.findChild(it, "version")?.text(),
-                scope = XmlUtil.findChild(it, "scope")?.text(),
-            )
-
-            if (!spec.isIncluded(dep)) it.parent().remove(it)
-        }
-    }
-}

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

@@ -1,189 +0,0 @@
-package cc.tweaked.gradle
-
-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
- * metadata, to make it easier to consume jars downstream.
- */
-class MinecraftConfigurations private constructor(private val project: Project) {
-    private val java = project.extensions.getByType(JavaPluginExtension::class.java)
-    private val sourceSets = java.sourceSets
-    private val configurations = project.configurations
-    private val objects = project.objects
-
-    private val main = sourceSets[SourceSet.MAIN_SOURCE_SET_NAME]
-    private val test = sourceSets[SourceSet.TEST_SOURCE_SET_NAME]
-
-    /**
-     * Performs the initial setup of our configurations.
-     */
-    private fun setup() {
-        // Define a client source set.
-        val client = sourceSets.maybeCreate("client")
-
-        // Ensure the client classpaths behave the same as the main ones.
-        configurations.named(client.compileClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
-        }
-
-        configurations.named(client.runtimeClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
-        }
-
-        // Set up an API configuration for clients (to ensure it's consistent with the main source set).
-        val clientApi = configurations.maybeCreate(client.apiConfigurationName).apply {
-            isVisible = false
-            isCanBeConsumed = false
-            isCanBeResolved = false
-        }
-        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)
-
-        // 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,
-        // but avoids accidentally pulling in Forge's obfuscated jar.
-        client.compileClasspath = client.compileClasspath + main.compileClasspath
-        client.runtimeClasspath = client.runtimeClasspath + main.runtimeClasspath
-        project.dependencies.add(client.apiConfigurationName, main.output)
-
-        // Also add client classes to the test classpath. We do the same nasty tricks as needed for main -> client.
-        test.compileClasspath += client.compileClasspath
-        test.runtimeClasspath += client.runtimeClasspath
-        project.dependencies.add(test.implementationConfigurationName, client.output)
-
-        // Configure some tasks to include our additional files.
-        project.tasks.named("javadoc", Javadoc::class.java) {
-            source(client.allJava)
-            classpath = main.compileClasspath + main.output + client.compileClasspath + client.output
-        }
-        // This are already done by Fabric, but we need it for Forge and vanilla. It shouldn't conflict at all.
-        project.tasks.named("jar", Jar::class.java) { from(client.output) }
-        project.tasks.named("sourcesJar", Jar::class.java) { from(client.allSource) }
-
-        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))
-            }
-
-            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) } }
-                }
-            }
-        }
-    }
-
-    companion object {
-        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
-}
-
-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
-}

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

@@ -1,191 +0,0 @@
-package cc.tweaked.gradle
-
-import org.gradle.api.GradleException
-import org.gradle.api.file.FileSystemOperations
-import org.gradle.api.invocation.Gradle
-import org.gradle.api.provider.Provider
-import org.gradle.api.services.BuildService
-import org.gradle.api.services.BuildServiceParameters
-import org.gradle.api.tasks.*
-import org.gradle.kotlin.dsl.getByName
-import org.gradle.language.base.plugins.LifecycleBasePlugin
-import java.io.File
-import java.nio.file.Files
-import java.util.concurrent.TimeUnit
-import java.util.function.Supplier
-import javax.inject.Inject
-import kotlin.random.Random
-
-/**
- * A [JavaExec] task for client-tests. This sets some common setup, and uses [MinecraftRunnerService] to ensure only one
- * test runs at once.
- */
-abstract class ClientJavaExec : JavaExec() {
-    private val clientRunner: Provider<MinecraftRunnerService> = MinecraftRunnerService.get(project.gradle)
-
-    init {
-        group = LifecycleBasePlugin.VERIFICATION_GROUP
-        usesService(clientRunner)
-    }
-
-    /**
-     * When [false], tests will not be run automatically, allowing the user to debug rendering.
-     */
-    @get:Input
-    val clientDebug get() = project.hasProperty("clientDebug")
-
-    /**
-     * When [false], tests will not run under a framebuffer.
-     */
-    @get:Input
-    val useFramebuffer get() = !clientDebug && !project.hasProperty("clientNoFramebuffer")
-
-    /**
-     * The path test results are written to.
-     */
-    @get:OutputFile
-    val testResults = project.layout.buildDirectory.file("test-results/$name.xml")
-
-    /**
-     * Copy configuration from a task with the given name.
-     */
-    fun copyFrom(path: String) = copyFrom(project.tasks.getByName(path, JavaExec::class))
-
-    /**
-     * Copy configuration from an existing [JavaExec] task.
-     */
-    fun copyFrom(task: JavaExec) {
-        for (dep in task.dependsOn) dependsOn(dep)
-        task.copyToFull(this)
-
-        if (!clientDebug) systemProperty("cctest.client", "")
-        systemProperty("cctest.gametest-report", testResults.get().asFile.absoluteFile)
-        workingDir(project.buildDir.resolve("gametest").resolve(name))
-    }
-
-    /**
-     * Only run tests with the given tags.
-     */
-    fun tags(vararg tags: String) {
-        systemProperty("cctest.tags", tags.joinToString(","))
-    }
-
-    /**
-     * Write a file with the given contents before starting Minecraft. This may be useful for writing config files.
-     */
-    fun withFileContents(path: Any, contents: Supplier<String>) {
-        val file = project.file(path).toPath()
-        doFirst {
-            Files.createDirectories(file.parent)
-            Files.writeString(file, contents.get())
-        }
-    }
-
-    /**
-     * Copy a file to the provided path before starting Minecraft. This copy only occurs if the file does not already
-     * exist.
-     */
-    fun withFileFrom(path: Any, source: Supplier<File>) {
-        val file = project.file(path).toPath()
-        doFirst {
-            Files.createDirectories(file.parent)
-            if (!Files.exists(file)) Files.copy(source.get().toPath(), file)
-        }
-    }
-
-    @TaskAction
-    override fun exec() {
-        Files.createDirectories(workingDir.toPath())
-        fsOperations.delete { delete(workingDir.resolve("screenshots")) }
-
-        if (useFramebuffer) {
-            clientRunner.get().wrapClient(this) { super.exec() }
-        } else {
-            super.exec()
-        }
-    }
-
-    @get:Inject
-    protected abstract val fsOperations: FileSystemOperations
-}
-
-/**
- * A service for [JavaExec] tasks which start Minecraft.
- *
- * Tasks may run `usesService(MinecraftRunnerService.get(gradle))` to ensure that only one Minecraft-related task runs
- * at once.
- */
-abstract class MinecraftRunnerService : BuildService<BuildServiceParameters.None> {
-    private val hasXvfb = lazy {
-        System.getProperty("os.name", "").equals("linux", ignoreCase = true) && ProcessHelpers.onPath("xvfb-run")
-    }
-
-    internal fun wrapClient(exec: JavaExec, run: () -> Unit) = when {
-        hasXvfb.value -> runXvfb(exec, run)
-        else -> run()
-    }
-
-    /**
-     * Run a program under Xvfb, preventing it spawning a window.
-     */
-    private fun runXvfb(exec: JavaExec, run: () -> Unit) {
-        fun ProcessBuilder.startVerbose(): Process {
-            exec.logger.info("Running ${this.command()}")
-            return start()
-        }
-
-        CloseScope().use { scope ->
-            val dir = Files.createTempDirectory("cctweaked").toAbsolutePath()
-            scope.add { fsOperations.delete { delete(dir) } }
-
-            val authFile = Files.createTempFile(dir, "Xauthority", "").toAbsolutePath()
-
-            val cookie = StringBuilder().also {
-                for (i in 0..31) it.append("0123456789abcdef"[Random.nextInt(16)])
-            }.toString()
-
-            val xvfb =
-                ProcessBuilder("Xvfb", "-displayfd", "1", "-screen", "0", "640x480x24", "-nolisten", "tcp").also {
-                    it.inheritIO()
-                    it.environment()["XAUTHORITY"] = authFile.toString()
-                    it.redirectOutput(ProcessBuilder.Redirect.PIPE)
-                }.startVerbose()
-            scope.add { xvfb.destroyForcibly().waitFor() }
-
-            val server = xvfb.inputReader().use { it.readLine().trim() }
-            exec.logger.info("Running at :$server (XAUTHORITY=$authFile.toA")
-
-            ProcessBuilder("xauth", "add", ":$server", ".", cookie).also {
-                it.inheritIO()
-                it.environment()["XAUTHORITY"] = authFile.toString()
-            }.startVerbose().waitForOrThrow("Failed to setup XAuthority file")
-
-            scope.add {
-                ProcessBuilder("xauth", "remove", ":$server").also {
-                    it.inheritIO()
-                    it.environment()["XAUTHORITY"] = authFile.toString()
-                }.startVerbose().waitFor()
-            }
-
-            // Wait a few seconds for Xvfb to start. Ugly, but identical to xvfb-run.
-            if (xvfb.waitFor(3, TimeUnit.SECONDS)) {
-                throw GradleException("Xvfb unexpectedly exited (with status code ${xvfb.exitValue()})")
-            }
-
-            exec.environment("XAUTHORITY", authFile.toString())
-            exec.environment("DISPLAY", ":$server")
-
-            run()
-        }
-    }
-
-    @get:Inject
-    protected abstract val fsOperations: FileSystemOperations
-
-    companion object {
-        fun get(gradle: Gradle): Provider<MinecraftRunnerService> =
-            gradle.sharedServices.registerIfAbsent("cc.tweaked.gradle.ClientJavaExec", MinecraftRunnerService::class.java) {
-                maxParallelUsages.set(1)
-            }
-    }
-}

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

@@ -1,50 +1,35 @@
 package cc.tweaked.gradle
 
 import org.codehaus.groovy.runtime.ProcessGroovyMethods
-import org.gradle.api.GradleException
 import java.io.BufferedReader
-import java.io.File
+import java.io.IOException
 import java.io.InputStreamReader
+import java.util.stream.Collectors
 
 internal object ProcessHelpers {
     fun startProcess(vararg command: String): Process {
         // Something randomly passes in "GIT_DIR=" as an environment variable which clobbers everything else. Don't
         // inherit the environment array!
-        return ProcessBuilder()
-            .command(*command)
-            .redirectError(ProcessBuilder.Redirect.INHERIT)
-            .also { it.environment().clear() }
-            .start()
+        return Runtime.getRuntime().exec(command, arrayOfNulls(0))
     }
 
     fun captureOut(vararg command: String): String {
         val process = startProcess(*command)
-        process.outputStream.close()
-
         val result = ProcessGroovyMethods.getText(process)
-        process.waitForOrThrow("Failed to run command")
+        if (process.waitFor() != 0) throw IOException("Command exited with a non-0 status")
         return result
     }
 
     fun captureLines(vararg command: String): List<String> {
-        val process = startProcess(*command)
-        process.outputStream.close()
+        return captureLines(startProcess(*command))
+    }
 
+    fun captureLines(process: Process): List<String> {
         val out = BufferedReader(InputStreamReader(process.inputStream)).use { reader ->
-            reader.lines().filter { it.isNotEmpty() }.toList()
+            reader.lines().filter { it.isNotEmpty() }.collect(Collectors.toList())
         }
         ProcessGroovyMethods.closeStreams(process)
-        process.waitForOrThrow("Failed to run command")
+        if (process.waitFor() != 0) throw IOException("Command exited with a non-0 status")
         return out
     }
-
-    fun onPath(name: String): Boolean {
-        val path = System.getenv("PATH") ?: return false
-        return path.splitToSequence(File.pathSeparator).any { File(it, name).exists() }
-    }
-}
-
-internal fun Process.waitForOrThrow(message: String) {
-    val ret = waitFor()
-    if (ret != 0) throw GradleException("$message (exited with $ret)")
 }

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

@@ -1,20 +0,0 @@
-package cc.tweaked.gradle
-
-import org.gradle.api.tasks.SourceSet
-
-data class SourceSetReference(
-    val sourceSet: SourceSet,
-    val classes: Boolean,
-    val external: Boolean,
-) {
-    companion object {
-        /** A source set in the current project. */
-        fun internal(sourceSet: SourceSet) = SourceSetReference(sourceSet, classes = true, external = false)
-
-        /** A source set from another project. */
-        fun external(sourceSet: SourceSet) = SourceSetReference(sourceSet, classes = true, external = true)
-
-        /** A source set which is inlined into the current project. */
-        fun inline(sourceSet: SourceSet) = SourceSetReference(sourceSet, classes = false, external = false)
-    }
-}

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

@@ -1,12 +0,0 @@
-package cc.tweaked.gradle
-
-import groovy.util.Node
-import groovy.util.NodeList
-
-object XmlUtil {
-    fun findChild(node: Node, name: String): Node? = when (val child = node.get(name)) {
-        is Node -> child
-        is NodeList -> child.singleOrNull() as Node?
-        else -> null
-    }
-}

config/checkstyle/checkstyle.xml

@@ -17,10 +17,7 @@
     <module name="TreeWalker">
         <!-- Annotations -->
         <module name="AnnotationLocation" />
-        <module name="AnnotationUseStyle">
-            <!-- We want trailing commas on multiline arrays. -->
-            <property name="trailingArrayComma" value="ignore" />
-        </module>
+        <module name="AnnotationUseStyle" />
         <module name="MissingDeprecated" />
         <module name="MissingOverride" />
 
@@ -29,11 +26,17 @@
         <module name="EmptyCatchBlock">
             <property name="exceptionVariableName" value="ignored" />
         </module>
-        <module name="LeftCurly" />
+        <module name="LeftCurly">
+            <property name="option" value="nl" />
+            <!-- The defaults, minus lambdas. -->
+            <property name="tokens" value="ANNOTATION_DEF,CLASS_DEF,CTOR_DEF,ENUM_CONSTANT_DEF,ENUM_DEF,INTERFACE_DEF,LITERAL_CASE,LITERAL_CATCH,LITERAL_DEFAULT,LITERAL_DO,LITERAL_ELSE,LITERAL_FINALLY,LITERAL_FOR,LITERAL_IF,LITERAL_SWITCH,LITERAL_SYNCHRONIZED,LITERAL_TRY,LITERAL_WHILE,METHOD_DEF,OBJBLOCK,STATIC_INIT" />
+        </module>
         <module name="NeedBraces">
             <property name="allowSingleLineStatement" value="true"/>
         </module>
-        <module name="RightCurly" />
+        <module name="RightCurly">
+            <property name="option" value="alone" />
+        </module>
 
         <!-- Class design. As if we've ever followed good practice here. -->
         <module name="FinalClass" />
@@ -111,7 +114,7 @@
         </module>
         <module name="MethodTypeParameterName" />
         <module name="PackageName">
-            <property name="format" value="^(dan200\.computercraft|cc\.tweaked)(\.[a-z][a-z0-9]*)*" />
+            <property name="format" value="^dan200\.computercraft(\.[a-z][a-z0-9]*)*" />
         </module>
         <module name="ParameterName" />
         <module name="StaticVariableName">
@@ -128,11 +131,18 @@
         <module name="MethodParamPad" />
         <module name="NoLineWrap" />
         <module name="NoWhitespaceAfter">
-            <property name="tokens" value="AT,INC,DEC,UNARY_MINUS,UNARY_PLUS,BNOT,LNOT,DOT,ARRAY_DECLARATOR,INDEX_OP,METHOD_REF" />
+            <property name="tokens" value="AT,INC,DEC,UNARY_MINUS,UNARY_PLUS,BNOT,LNOT,DOT,ARRAY_DECLARATOR,INDEX_OP" />
         </module>
         <module name="NoWhitespaceBefore" />
         <!-- TODO: Decide on an OperatorWrap style. -->
-        <module name="ParenPad" />
+        <module name="ParenPad">
+            <property name="option" value="space" />
+            <property name="tokens" value="ANNOTATION,ANNOTATION_FIELD_DEF,CTOR_CALL,CTOR_DEF,ENUM_CONSTANT_DEF,LITERAL_CATCH,LITERAL_DO,LITERAL_FOR,LITERAL_IF,LITERAL_NEW,LITERAL_SWITCH,LITERAL_SYNCHRONIZED,LITERAL_WHILE,METHOD_CALL,METHOD_DEF,RESOURCE_SPECIFICATION,SUPER_CTOR_CALL,LAMBDA" />
+        </module>
+        <module name="ParenPad">
+            <property name="option" value="nospace" />
+            <property name="tokens" value="DOT,EXPR,QUESTION" />
+        </module>
         <module name="SeparatorWrap">
             <property name="option" value="eol" />
             <property name="tokens" value="COMMA,SEMI,ELLIPSIS,ARRAY_DECLARATOR,RBRACK,METHOD_REF" />

config/idea/codeStyleSettings.xml

@@ -0,0 +1,61 @@
+<code_scheme name="Project" version="173">
+  <JSON>
+    <option name="OBJECT_WRAPPING" value="1" />
+    <option name="ARRAY_WRAPPING" value="1" />
+  </JSON>
+  <JavaCodeStyleSettings>
+    <option name="PACKAGES_TO_USE_IMPORT_ON_DEMAND">
+      <value />
+    </option>
+    <option name="JD_P_AT_EMPTY_LINES" value="false" />
+    <option name="JD_PRESERVE_LINE_FEEDS" value="true" />
+  </JavaCodeStyleSettings>
+  <codeStyleSettings language="JAVA">
+    <option name="KEEP_FIRST_COLUMN_COMMENT" value="false" />
+    <option name="BRACE_STYLE" value="2" />
+    <option name="CLASS_BRACE_STYLE" value="2" />
+    <option name="METHOD_BRACE_STYLE" value="2" />
+    <option name="LAMBDA_BRACE_STYLE" value="5" />
+    <option name="ELSE_ON_NEW_LINE" value="true" />
+    <option name="CATCH_ON_NEW_LINE" value="true" />
+    <option name="FINALLY_ON_NEW_LINE" value="true" />
+    <option name="SPACE_WITHIN_METHOD_CALL_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_METHOD_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_IF_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_WHILE_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_FOR_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_TRY_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_CATCH_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_SWITCH_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_SYNCHRONIZED_PARENTHESES" value="true" />
+    <option name="SPACE_WITHIN_ARRAY_INITIALIZER_BRACES" value="true" />
+    <option name="SPACE_BEFORE_IF_PARENTHESES" value="false" />
+    <option name="SPACE_BEFORE_WHILE_PARENTHESES" value="false" />
+    <option name="SPACE_BEFORE_FOR_PARENTHESES" value="false" />
+    <option name="SPACE_BEFORE_TRY_PARENTHESES" value="false" />
+    <option name="SPACE_BEFORE_CATCH_PARENTHESES" value="false" />
+    <option name="SPACE_BEFORE_SWITCH_PARENTHESES" value="false" />
+    <option name="SPACE_BEFORE_SYNCHRONIZED_PARENTHESES" value="false" />
+    <option name="SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE" value="true" />
+    <option name="KEEP_SIMPLE_METHODS_IN_ONE_LINE" value="true" />
+    <option name="KEEP_SIMPLE_LAMBDAS_IN_ONE_LINE" value="true" />
+    <option name="KEEP_SIMPLE_CLASSES_IN_ONE_LINE" value="true" />
+    <option name="IF_BRACE_FORCE" value="1" />
+    <option name="DOWHILE_BRACE_FORCE" value="1" />
+    <option name="WHILE_BRACE_FORCE" value="1" />
+    <option name="FOR_BRACE_FORCE" value="1" />
+    <option name="SPACE_WITHIN_ANNOTATION_PARENTHESES" value="true" />
+    <indentOptions>
+      <option name="CONTINUATION_INDENT_SIZE" value="4" />
+    </indentOptions>
+  </codeStyleSettings>
+  <codeStyleSettings language="JSON">
+    <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
+    <option name="SPACE_WITHIN_BRACKETS" value="true" />
+    <option name="SPACE_WITHIN_BRACES" value="true" />
+    <indentOptions>
+      <option name="INDENT_SIZE" value="4" />
+      <option name="CONTINUATION_INDENT_SIZE" value="4" />
+    </indentOptions>
+  </codeStyleSettings>
+</code_scheme>

gradle.properties

@@ -5,8 +5,7 @@ kotlin.stdlib.default.dependency=false
 kotlin.jvm.target.validation.mode=error
 
 # Mod properties
-isUnstable=true
-modVersion=1.102.0
+modVersion=1.101.2
 
 # Minecraft properties: We want to configure this here so we can read it in settings.gradle
-mcVersion=1.19.3
+mcVersion=1.19.2

gradle/libs.versions.toml

@@ -2,152 +2,70 @@
 
 # Minecraft
 # MC version is specified in gradle.properties, as we need that in settings.gradle.
-fabric-api = "0.68.1+1.19.3"
-fabric-loader = "0.14.11"
-forge = "44.0.18"
-forgeSpi = "6.0.0"
-mixin = "0.8.5"
-parchment = "2022.11.27"
+forge = "43.1.1"
+parchment = "2022.10.16"
 parchmentMc = "1.19.2"
 
-# Normal dependencies
-asm = "9.3"
 autoService = "1.0.1"
-checkerFramework = "3.12.0"
-cobalt = "0.5.9"
-fastutil = "8.5.9"
-guava = "31.1-jre"
+cobalt = "0.6.0"
 jetbrainsAnnotations = "23.0.0"
-jsr305 = "3.0.2"
 kotlin = "1.7.10"
 kotlin-coroutines = "1.6.0"
-netty = "4.1.82.Final"
-nightConfig = "3.6.5"
-slf4j = "1.7.36"
-
-# Minecraft mods
-forgeConfig = "5.0.3"
-iris = "1.19.3-v1.4.6"
-jei = "11.3.0.262"
-modmenu = "5.0.1"
-oculus = "1.2.5"
-rei = "10.0.578"
-rubidium = "0.6.1"
-sodium = "mc1.19.3-0.4.6"
 
 # Testing
-byteBuddy = "1.12.19"
 hamcrest = "2.2"
 jqwik = "1.7.0"
 junit = "5.9.1"
 
 # Build tools
-cctJavadoc = "1.5.3"
+cctJavadoc = "1.5.2"
 checkstyle = "10.3.4"
 curseForgeGradle = "1.0.11"
-errorProne-core = "2.14.0"
-errorProne-plugin = "2.0.2"
-fabric-loom = "1.0-SNAPSHOT"
 forgeGradle = "5.1.+"
 githubRelease = "2.2.12"
-ideaExt = "1.1.6"
-illuaminate = "0.1.0-7-g2a5a89c"
+illuaminate = "0.1.0-20-g8c483a4"
 librarian = "1.+"
 minotaur = "2.+"
 mixinGradle = "0.7.+"
-nullAway = "0.9.9"
-quiltflower = "1.7.3"
 shadow = "7.1.2"
 spotless = "6.8.0"
 taskTree = "2.1.0"
-vanillaGradle = "0.2.1-SNAPSHOT"
 
 [libraries]
-# Normal dependencies
-asm = { module = "org.ow2.asm:asm", version.ref = "asm" }
 autoService = { module = "com.google.auto.service:auto-service", version.ref = "autoService" }
-checkerFramework = { module = "org.checkerframework:checker-qual", version.ref = "checkerFramework" }
 cobalt = { module = "org.squiddev:Cobalt", version.ref = "cobalt" }
-fastutil = { module = "it.unimi.dsi:fastutil", version.ref = "fastutil" }
-forgeSpi = { module = "net.minecraftforge:forgespi", version.ref = "forgeSpi" }
-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" }
 kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk8", version.ref = "kotlin" }
-netty-http = { module = "io.netty:netty-codec-http", version.ref = "netty" }
-nightConfig-core = { module = "com.electronwill.night-config:core", version.ref = "nightConfig" }
-nightConfig-toml = { module = "com.electronwill.night-config:toml", version.ref = "nightConfig" }
-slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
-
-# Minecraft mods
-fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version.ref = "fabric-api" }
-fabric-loader = { module = "net.fabricmc:fabric-loader", version.ref = "fabric-loader" }
-forgeConfig = { module = "fuzs.forgeconfigapiport:forgeconfigapiport-fabric", version.ref = "forgeConfig" }
-iris = { module = "maven.modrinth:iris", version.ref = "iris" }
-jei-api = { module = "mezz.jei:jei-1.19.2-common-api", version.ref = "jei" }
-jei-fabric = { module = "mezz.jei:jei-1.19.2-fabric", version.ref = "jei" }
-jei-forge = { module = "mezz.jei:jei-1.19.2-forge", version.ref = "jei" }
-mixin = { module = "org.spongepowered:mixin", version.ref = "mixin" }
-modmenu = { module = "com.terraformersmc:modmenu", version.ref = "modmenu" }
-oculus = { module = "maven.modrinth:oculus", version.ref = "oculus" }
-rei-api = { module = "me.shedaniel:RoughlyEnoughItems-api", version.ref = "rei" }
-rei-builtin = { module = "me.shedaniel:RoughlyEnoughItems-default-plugin", version.ref = "rei" }
-rei-fabric = { module = "me.shedaniel:RoughlyEnoughItems-fabric", version.ref = "rei" }
-rubidium = { module = "maven.modrinth:rubidium", version.ref = "rubidium" }
-sodium = { module = "maven.modrinth:sodium", version.ref = "sodium" }
 
 # Testing
-byteBuddyAgent = { module ="net.bytebuddy:byte-buddy-agent", version.ref = "byteBuddy" }
-byteBuddy = { module ="net.bytebuddy:byte-buddy", version.ref = "byteBuddy" }
 hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "hamcrest" }
 jqwik-api = { module = "net.jqwik:jqwik-api", version.ref = "jqwik" }
 jqwik-engine = { module = "net.jqwik:jqwik-engine", version.ref = "jqwik" }
 junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
 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" }
 
 # Build tools
 cctJavadoc = { module = "cc.tweaked:cct-javadoc", version.ref = "cctJavadoc" }
 checkstyle = { module = "com.puppycrawl.tools:checkstyle", version.ref = "checkstyle" }
-errorProne-annotations = { module = "com.google.errorprone:error_prone_annotations", version.ref = "errorProne-core" }
-errorProne-api = { module = "com.google.errorprone:error_prone_check_api", version.ref = "errorProne-core" }
-errorProne-core = { module = "com.google.errorprone:error_prone_core", version.ref = "errorProne-core" }
-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" }
 kotlin-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
-librarian = { module = "org.parchmentmc:librarian", version.ref = "librarian" }
-nullAway = { module = "com.uber.nullaway:nullaway", version.ref = "nullAway" }
-quiltflower = { module = "io.github.juuxel:loom-quiltflower", version.ref = "quiltflower" }
 spotless = { module = "com.diffplug.spotless:spotless-plugin-gradle", version.ref = "spotless" }
-vanillaGradle = { module = "org.spongepowered:vanillagradle", version.ref = "vanillaGradle" }
 
 [plugins]
-curseForgeGradle = { id = "net.darkhax.curseforgegradle", version.ref = "curseForgeGradle" }
-forgeGradle = { id = "net.minecraftforge.gradle", version.ref = "forgeGradle" }
-githubRelease = { id = "com.github.breadmoirai.github-release", version.ref = "githubRelease" }
-ideaExt = { id = "org.jetbrains.gradle.plugin.idea-ext", version.ref = "ideaExt" }
 kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
-librarian = { id = "org.parchmentmc.librarian.forgegradle", version.ref = "librarian" }
-minotaur = { id = "com.modrinth.minotaur", version.ref = "minotaur" }
-mixinGradle = { id = "org.spongepowered.mixin", version.ref = "mixinGradle" }
-shadow = { id = "com.github.johnrengelman.shadow", version.ref = "shadow" }
 taskTree = { id = "com.dorongold.task-tree", version.ref = "taskTree" }
+curseForgeGradle = { id = "net.darkhax.curseforgegradle", version.ref = "curseForgeGradle" }
+mixinGradle = { id = "org.spongepowered.mixin", version.ref = "mixinGradle" }
+minotaur = { id = "com.modrinth.minotaur", version.ref = "minotaur" }
+githubRelease = { id = "com.github.breadmoirai.github-release", version.ref = "githubRelease" }
+forgeGradle = { id = "net.minecraftforge.gradle", version.ref = "forgeGradle" }
+librarian = { id = "org.parchmentmc.librarian.forgegradle", version.ref = "librarian" }
+shadow = { id = "com.github.johnrengelman.shadow", version.ref = "shadow" }
 
 [bundles]
 kotlin = ["kotlin-stdlib", "kotlin-coroutines"]
 
-# Minecraft
-externalMods-common = ["jei-api", "forgeConfig", "nightConfig-core", "nightConfig-toml"]
-externalMods-forge-compile = ["oculus", "jei-api"]
-externalMods-forge-runtime = []
-externalMods-fabric = ["fabric-loader", "fabric-api", "forgeConfig", "nightConfig-core", "nightConfig-toml"]
-externalMods-fabric-compile = ["iris", "jei-api", "rei-api", "rei-builtin"]
-externalMods-fabric-runtime = ["modmenu"]
-
 # Testing
 test = ["junit-jupiter-api", "junit-jupiter-params", "hamcrest", "jqwik-api"]
 testRuntime = ["junit-jupiter-engine", "jqwik-engine"]

illuaminate.sexp

@@ -2,26 +2,25 @@
 
 (sources
   /doc/
-  /projects/forge/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
-  /projects/web/src/mount)
+  /build/docs/luaJavadoc/
+  /src/main/resources/*/computercraft/lua/bios.lua
+  /src/main/resources/*/computercraft/lua/rom/
+  /src/test/resources/test-rom
+  /src/web/mount)
 
 
 (doc
-  ; Also defined in projects/web/build.gradle.kts
-  (destination /projects/web/build/illuaminate)
+  (destination build/illuaminate)
   (index doc/index.md)
 
   (site
     (title "CC: Tweaked")
-    (logo projects/common/src/main/resources/pack.png)
+    (logo src/main/resources/pack.png)
     (url https://tweaked.cc/)
     (source-link https://github.com/cc-tweaked/CC-Tweaked/blob/${commit}/${path}#L${line})
 
-    (styles /projects/web/src/styles.css)
-    (scripts /projects/web/build/rollup/index.js)
+    (styles src/web/styles.css)
+    (scripts build/rollup/index.js)
     (head doc/head.html))
 
   (module-kinds
@@ -33,15 +32,15 @@
 
   (library-path
     /doc/stub/
-    /projects/forge/build/docs/luaJavadoc/
+    /build/docs/luaJavadoc/
 
-    /projects/core/src/main/resources/data/computercraft/lua/rom/apis/
-    /projects/core/src/main/resources/data/computercraft/lua/rom/apis/command/
-    /projects/core/src/main/resources/data/computercraft/lua/rom/apis/turtle/
+    /src/main/resources/*/computercraft/lua/rom/apis/
+    /src/main/resources/*/computercraft/lua/rom/apis/command/
+    /src/main/resources/*/computercraft/lua/rom/apis/turtle/
 
-    /projects/core/src/main/resources/data/computercraft/lua/rom/modules/main/
-    /projects/core/src/main/resources/data/computercraft/lua/rom/modules/command/
-    /projects/core/src/main/resources/data/computercraft/lua/rom/modules/turtle/))
+    /src/main/resources/*/computercraft/lua/rom/modules/main/
+    /src/main/resources/*/computercraft/lua/rom/modules/command/
+    /src/main/resources/*/computercraft/lua/rom/modules/turtle/))
 
 (at /
   (linters
@@ -81,31 +80,31 @@
 ;; We disable the unused global linter in bios.lua and the APIs. In the future
 ;; hopefully we'll get illuaminate to handle this.
 (at
-  (/projects/core/src/main/resources/data/computercraft/lua/bios.lua
-   /projects/core/src/main/resources/data/computercraft/lua/rom/apis/)
+  (/src/main/resources/*/computercraft/lua/bios.lua
+   /src/main/resources/*/computercraft/lua/rom/apis/)
   (linters -var:unused-global)
   (lint (allow-toplevel-global true)))
 
 ;; Silence some variable warnings in documentation stubs.
-(at (/doc/stub/ /projects/forge/build/docs/luaJavadoc/)
+(at (/doc/stub/ /build/docs/luaJavadoc/)
   (linters -var:unused-global)
   (lint (allow-toplevel-global true)))
 
 ;; Suppress warnings for currently undocumented modules.
 (at
   (; Lua APIs
-   /projects/core/src/main/resources/data/computercraft/lua/rom/apis/io.lua
-   /projects/core/src/main/resources/data/computercraft/lua/rom/apis/window.lua)
+   /src/main/resources/*/computercraft/lua/rom/apis/io.lua
+   /src/main/resources/*/computercraft/lua/rom/apis/window.lua)
 
   (linters -doc:undocumented -doc:undocumented-arg -doc:undocumented-return))
 
 ;; Suppress warnings for various APIs using its own deprecated members.
 (at
-  (/projects/core/src/main/resources/data/computercraft/lua/bios.lua
-   /projects/core/src/main/resources/data/computercraft/lua/rom/apis/turtle/turtle.lua)
+  (/src/main/resources/*/computercraft/lua/bios.lua
+   /src/main/resources/*/computercraft/lua/rom/apis/turtle/turtle.lua)
   (linters -var:deprecated))
 
-(at /projects/core/src/test/resources/test-rom
+(at /src/test/resources/test-rom
   ; We should still be able to test deprecated members.
   (linters -var:deprecated)
 
@@ -114,4 +113,4 @@
       :max sleep write
       cct_test describe expect howlci fail it pending stub before_each)))
 
-(at /projects/web/src/mount/expr_template.lua (lint (globals :max __expr__)))
+(at /src/web/mount/expr_template.lua (lint (globals :max __expr__)))

projects/ARCHITECTURE.md

@@ -1,159 +0,0 @@
-# Architecture
-CC: Tweaked has a rather complex project layout, as there's several use-cases we want to support (multiple mod loaders,
-usable outside of Minecraft). As such, it can be tricky to understand how the code is structured and how the various
-sub-projects interact. This document provides a high-level overview of the entire mod.
-
-## Project Outline
-CC: Tweaked is split into 4 primary modules (`core`, `common`, `fabric`, `forge`). These themselves are then split into
-a public API (i.e `core-api`) and the actual implementation (i.e. `core`).
-
- - `core`: This contains the core "computer" part of ComputerCraft, such as the Lua VM, filesystem and builtin APIs.
-   This is also where the Lua ROM is located (`projects/core/src/main/resources/data/computercraft/lua`). Notably this
-   project does _not_ depend on Minecraft, making it possible to use it in emulators and other tooling.
-
- - `common`: This contains all non mod-loader-specific Minecraft code. This is where computers, turtles and peripherals
-   are defined (and everything else Minecraft-related!).
-
-   This project is separates client code into its own separate source set (suitably named `client`). This helps us
-   ensure that server code can never reference client-only code (such as LWJGL).
-
- - `forge` and `fabric`: These contain any mod-loader specific code.
-
-When we need to call loader-specific code from our own code (for instance, sending network messages or firing
-loader-specific events), we use a `PlatformHelper` interface (defined in
-`projects/common/src/main/java/dan200/computercraft/shared/platform/PlatformHelper.java`). This abstracts over most
-loader-specific code we need to use, and is then implemented by each mod-loader-specific project. The concrete
-implementation is then loaded with Java's [`ServiceLoader`][ServiceLoader], in a design based on [jaredlll08's
-multi-loader template][MultiLoader-Template]. We use a similar system for communicating between the API and its
-implementation.
-
-```mermaid
-flowchart LR
-subgraph Common
-    platform(PlatformHelper)
-    impl[AbstractComputerCraftAPI]
-end
-subgraph API
-    api(ComputerCraft API) --> impl
-end
-subgraph Forge[Forge]
-    platform --> forgePlatform[PlatformHelperImpl]
-    impl -.-> forgeImpl[ComputerCraftAPIImpl]
-end
-subgraph Fabric
-    platform --> fabricPlatform[PlatformHelperImpl]
-    impl -.-> fabricImpl[ComputerCraftAPIImpl]
-end
-```
-
-Note the `PlatformHelper` is only used when calling from our code into loader-specific code. While we use this to _fire_
-events, we do not use it to _subscribe_ to events. For that we just subscribe to the events in the loader-specific
-project, and then dispatch to the common `CommonHooks` (for shared code) and `ClientHooks` (for client-specific code).
-
-You may notice there's a couple of other, smaller modules in the codebase. These you can probably ignore, but are worth
-mentioning:
-
- - `lints`: This defines an [ErrorProne] plugin which adds a couple of compile-time checks to our code. This is what
-   enforces that no client-specific code is used inside the `main` source set (and a couple of other things!).
-
- - `web`: This contains the additional tooling for building [the documentation website][tweaked.cc], such as support for
-   rendering recipes
-
- - `buildSrc` (in the base directory, not in `projects/`): This contains any build logic shared between modules. For
-   instance, `cc-tweaked.java-convention.gradle.kts` sets up the defaults for Java that we use across the whole project.
-
-> **Note**
-> The Forge and Fabric modules (and their API counterparts) depend on the common modules. However, in order to correctly
-> process mixins we need to compile the common code along with the Forge/Fabric code. This leads to a slightly strange
-> build process:
->
->  - In your IDE, Forge/Fabric depend on the common as normal.
->  - When building via Gradle, the common code is compiled alongside Forge/Fabric.
->
-> You shouldn't need to worry about this - it should all be set up automatically - but hopefully explains a little bit
-> why our Gradle scripts are slightly odd!
-
-## Testing
-CC: Tweaked has a small (though growing!) test suite to ensure various features behave correctly. Most tests are written
-in Java using [JUnit], though we also make use of [jqwik] for property testing.
-
-### Test Fixtures
-Some projects define an additional `testFixtures` folder alongside their main `test` code (i.e.
-`projects/core/src/testFixtures`). This source set contains test-related code which might be consumed in dependent
-projects. For instance, core's test fixtures defines additional [Hamcrest] matchers, which are used in both `core` and
-`common`'s test suite.
-
-Test fixtures may also define [Test Interfaces]. This is a pattern for writing tests to ensure that an implementation
-obeys its interface's contract. For instance, we might have a `ListContract` test, which asserts an abstract list
-behaves as expected:
-
-```java
-interface ListContract<T extends List<Integer>> {
-    T newList();
-
-    @Test
-    default void testAddInsert() {
-        var list = newList();
-        assertTrue(list.add(123));
-        assertTrue(list.contains(123));
-    }
-}
-```
-
-We can then use this interface to create tests for a specific implementation:
-
-```java
-class ArrayListTest implements ListContract<ArrayList<Integer>> {
-    @Override public ArrayList<Integer> newList() { return new ArrayList<>(); }
-}
-```
-
-This is especially useful when testing `PlatformHelper` and other mod loader abstractions.
-
-### Lua tests
-While the majority of CC: Tweaked is written in Java, a significant portion of the code is written in Lua. As such, it's
-also useful to test that.
-
-This is done by starting a Lua VM with all of ComputerCraft's APIs loaded, then starting a custom test framework
-(`mcfly.lua`). This test framework discovers tests and sends them back to the Java side. These are turned into JUnit
-tests which are then in turn run on the computer again. This allows the tests to integrate with existing Java testing
-tooling (for instance, XML test reports and IDE integration).
-
-There's a slightly more detailed description of the process at `ComputerTestDelegate.java`.
-
-### Game tests
-CC: Tweaked also runs several tests in-game using Minecraft's [gametest framework][mc-test]. These work by starting
-a Minecraft server and then, for each test, spawning a structure and then interacting with the blocks inside the
-structure, asserting they behave as expected.
-
-Unlike most of our other tests, these are written in Kotlin. We make extensive use of [extension methods] to augment
-vanilla's own test classes, which helps give a more consistent feel to the API.
-
-Each test works by defining a sequence of steps. Each step can either run an action (`thenExecute`), sleep for a period
-(`thenIdle`) or sleep until a condition is met (`thenWaitUntil`).
-
-```kotlin
-fun Some_test(context: GameTestHelper) = context.sequence {
-    thenExecute { context.setBlock(BlockPos(2, 2, 2), Blocks.AIR) }
-    thenIdle(4)
-    thenExecute { context.assertBlockHas(lamp, RedstoneLampBlock.LIT, false, "Lamp should not be lit") }
-}
-```
-
-Some tests need to use Lua APIs from a computer, such as when testing `turtle.dig`. In order to do this, we install
-a custom "Lua" runtime (see `ManagedComputers.kt`) which actually runs Java functions. Tests can then enqueue a function
-to run on a particular computer and then wait for it to finish.
-
-While the internals of this is quite complex, it ends up being a much nicer workflow than writing parts of the test in
-Lua. It also ends up being much more efficient, which is important when running a dozen tests at once!
-
-[MultiLoader-Template]: https://github.com/jaredlll08/MultiLoader-Template/ "MultiLoader-Template - A template for a Forge + Fabric project setup using a Common source set."
-[ServiceLoader]: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/ServiceLoader.html "ServiceLoader (Java SE 17 and JDK 17)"
-[ErrorProne]: https://errorprone.info/ "ErrorProne"
-[tweaked.cc]: https://tweaked.cc "CC: Tweaked"
-[JUnit]: https://junit.org/junit5/ "JUnit 5"
-[jqwik]: https://jqwik.net/
-[Hamcrest]: https://hamcrest.org/JavaHamcrest/ "Java Hamcrest"
-[Test Interfaces]: https://junit.org/junit5/docs/current/user-guide/#writing-tests-test-interfaces-and-default-methods
-[mc-test]: https://www.youtube.com/watch?v=vXaWOJTCYNg "Testing Minecraft in Minecraft on YouTube"
-[extension methods]: https://kotlinlang.org/docs/extensions.html "Extensions | Kotlin"

projects/common-api/build.gradle.kts

@@ -1,20 +0,0 @@
-plugins {
-    id("cc-tweaked.java-convention")
-    id("cc-tweaked.publishing")
-    id("cc-tweaked.vanilla")
-}
-
-java {
-    withJavadocJar()
-}
-
-dependencies {
-    api(project(":core-api"))
-}
-
-tasks.javadoc {
-    include("dan200/computercraft/api/**/*.java")
-
-    // 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 })
-}

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

@@ -1,57 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
- * For help using the API, and posting your mods, visit the forums at computercraft.info.
- */
-package dan200.computercraft.api.client;
-
-import com.mojang.math.Transformation;
-import dan200.computercraft.impl.client.ClientPlatformHelper;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.resources.model.BakedModel;
-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.
- */
-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 TransformedModel(BakedModel model) {
-        this.model = Objects.requireNonNull(model);
-        matrix = Transformation.identity();
-    }
-
-    public static TransformedModel of(ModelResourceLocation location) {
-        var modelManager = Minecraft.getInstance().getModelManager();
-        return new TransformedModel(modelManager.getModel(location));
-    }
-
-    public static TransformedModel of(ResourceLocation location) {
-        var modelManager = Minecraft.getInstance().getModelManager();
-        return new TransformedModel(ClientPlatformHelper.get().getModel(modelManager, location));
-    }
-
-    public static TransformedModel of(ItemStack item, Transformation transform) {
-        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/impl/client/ClientPlatformHelper.java

@@ -1,46 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.impl.client;
-
-import dan200.computercraft.impl.Services;
-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.ApiStatus;
-
-import javax.annotation.Nullable;
-
-@ApiStatus.Internal
-public interface ClientPlatformHelper {
-    /**
-     * Equivalent to {@link ModelManager#getModel(ModelResourceLocation)} but for arbitrary {@link ResourceLocation}s.
-     *
-     * @param manager  The model manager.
-     * @param location The model location.
-     * @return The baked model.
-     */
-    BakedModel getModel(ModelManager manager, ResourceLocation location);
-
-    static ClientPlatformHelper get() {
-        var instance = Instance.INSTANCE;
-        return instance == null ? Services.raise(ClientPlatformHelper.class, Instance.ERROR) : instance;
-    }
-
-    final class Instance {
-        static final @Nullable ClientPlatformHelper INSTANCE;
-        static final @Nullable Throwable ERROR;
-
-        static {
-            var helper = Services.tryLoad(ClientPlatformHelper.class);
-            INSTANCE = helper.instance();
-            ERROR = helper.error();
-        }
-
-        private Instance() {
-        }
-    }
-}

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

@@ -1,203 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
- * For help using the API, and posting your mods, visit the forums at computercraft.info.
- */
-package dan200.computercraft.api;
-
-import dan200.computercraft.api.filesystem.Mount;
-import dan200.computercraft.api.filesystem.WritableMount;
-import dan200.computercraft.api.lua.GenericSource;
-import dan200.computercraft.api.lua.ILuaAPI;
-import dan200.computercraft.api.lua.ILuaAPIFactory;
-import dan200.computercraft.api.media.IMedia;
-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.peripheral.IComputerAccess;
-import dan200.computercraft.api.redstone.BundledRedstoneProvider;
-import dan200.computercraft.api.turtle.ITurtleAccess;
-import dan200.computercraft.api.turtle.TurtleRefuelHandler;
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.Level;
-
-import javax.annotation.Nullable;
-
-/**
- * The static entry point to the ComputerCraft API.
- * <p>
- * Members in this class must be called after ComputerCraft has been initialised, but may be called before it is
- * fully loaded.
- */
-public final class ComputerCraftAPI {
-    public static final String MOD_ID = "computercraft";
-
-    public static String getInstalledVersion() {
-        return getInstance().getInstalledVersion();
-    }
-
-    /**
-     * Creates a numbered directory in a subfolder of the save directory for a given world, and returns that number.
-     * <p>
-     * Use in conjunction with createSaveDirMount() to create a unique place for your peripherals or media items to store files.
-     *
-     * @param server        The server for which the save dir should be created.
-     * @param parentSubPath The folder path within the save directory where the new directory should be created. eg: "computercraft/disk"
-     * @return The numerical value of the name of the new folder, or -1 if the folder could not be created for some reason.
-     * <p>
-     * eg: if createUniqueNumberedSaveDir( world, "computer/disk" ) was called returns 42, then "computer/disk/42" is now
-     * available for writing.
-     * @see #createSaveDirMount(MinecraftServer, String, long)
-     */
-    public static int createUniqueNumberedSaveDir(MinecraftServer server, String parentSubPath) {
-        return getInstance().createUniqueNumberedSaveDir(server, parentSubPath);
-    }
-
-    /**
-     * Creates a file system mount that maps to a subfolder of the save directory for a given world, and returns it.
-     * <p>
-     * Use in conjunction with Use {@link IComputerAccess#mount(String, Mount)} or {@link IComputerAccess#mountWritable(String, WritableMount)}
-     * to mount this on a computer's file system.
-     * <p>
-     * If the same folder may be mounted on multiple computers at once (for instance, if you provide a network file share),
-     * the same mount instance should be used for all computers. You should NOT have multiple mount instances for the
-     * same folder.
-     *
-     * @param server   The server which the save dir can be found.
-     * @param subPath  The folder path within the save directory that the mount should map to. eg: "disk/42".
-     *                 Use {@link #createUniqueNumberedSaveDir(MinecraftServer, String)} to create a new numbered folder
-     *                 to use.
-     * @param capacity The amount of data that can be stored in the directory before it fills up, in bytes.
-     * @return The newly created mount.
-     * @see #createUniqueNumberedSaveDir(MinecraftServer, String)
-     * @see IComputerAccess#mount(String, Mount)
-     * @see IComputerAccess#mountWritable(String, WritableMount)
-     * @see Mount
-     * @see WritableMount
-     */
-    public static WritableMount createSaveDirMount(MinecraftServer server, String subPath, long capacity) {
-        return getInstance().createSaveDirMount(server, subPath, capacity);
-    }
-
-    /**
-     * Creates a file system mount to a resource folder, and returns it.
-     * <p>
-     * Use in conjunction with {@link IComputerAccess#mount} or {@link IComputerAccess#mountWritable} to mount a
-     * resource folder onto a computer's file system.
-     * <p>
-     * The files in this mount will be a combination of files in all mod jar, and data packs that contain
-     * resources with the same domain and path. For instance, ComputerCraft's resources are stored in
-     * "/data/computercraft/lua/rom". We construct a mount for that with
-     * {@code createResourceMount("computercraft", "lua/rom")}.
-     *
-     * @param server  The current Minecraft server, from which to read resources from.
-     * @param domain  The domain under which to look for resources. eg: "mymod".
-     * @param subPath The subPath under which to look for resources. eg: "lua/myfiles".
-     * @return The mount, or {@code null} if it could be created for some reason.
-     * @see IComputerAccess#mount(String, Mount)
-     * @see IComputerAccess#mountWritable(String, WritableMount)
-     * @see Mount
-     */
-    @Nullable
-    public static Mount createResourceMount(MinecraftServer server, String domain, String subPath) {
-        return getInstance().createResourceMount(server, domain, subPath);
-    }
-
-    /**
-     * Registers a method source for generic peripherals.
-     *
-     * @param source The method source to register.
-     * @see GenericSource
-     */
-    public static void registerGenericSource(GenericSource source) {
-        getInstance().registerGenericSource(source);
-    }
-
-    /**
-     * Registers a bundled redstone provider to provide bundled redstone output for blocks.
-     *
-     * @param provider The bundled redstone provider to register.
-     * @see BundledRedstoneProvider
-     */
-    public static void registerBundledRedstoneProvider(BundledRedstoneProvider provider) {
-        getInstance().registerBundledRedstoneProvider(provider);
-    }
-
-    /**
-     * If there is a Computer or Turtle at a certain position in the world, get it's bundled redstone output.
-     *
-     * @param world The world this block is in.
-     * @param pos   The position this block is at.
-     * @param side  The side to extract the bundled redstone output from.
-     * @return If there is a block capable of emitting bundled redstone at the location, it's signal (0-65535) will be returned.
-     * If there is no block capable of emitting bundled redstone at the location, -1 will be returned.
-     * @see BundledRedstoneProvider
-     */
-    public static int getBundledRedstoneOutput(Level world, BlockPos pos, Direction side) {
-        return getInstance().getBundledRedstoneOutput(world, pos, side);
-    }
-
-    /**
-     * Registers a media provider to provide {@link IMedia} implementations for Items.
-     *
-     * @param provider The media provider to register.
-     * @see MediaProvider
-     */
-    public static void registerMediaProvider(MediaProvider provider) {
-        getInstance().registerMediaProvider(provider);
-    }
-
-    /**
-     * Attempt to get the game-wide wireless network.
-     *
-     * @param server The current Minecraft server.
-     * @return The global wireless network, or {@code null} if it could not be fetched.
-     */
-    public static PacketNetwork getWirelessNetwork(MinecraftServer server) {
-        return getInstance().getWirelessNetwork(server);
-    }
-
-    /**
-     * Register a custom {@link ILuaAPI}, which may be added onto all computers without requiring a peripheral.
-     * <p>
-     * Before implementing this interface, consider alternative methods of providing methods. It is generally preferred
-     * to use peripherals to provide functionality to users.
-     *
-     * @param factory The factory for your API subclass.
-     * @see ILuaAPIFactory
-     */
-    public static void registerAPIFactory(ILuaAPIFactory factory) {
-        getInstance().registerAPIFactory(factory);
-    }
-
-    /**
-     * Construct a new wired node for a given wired element.
-     *
-     * @param element The element to construct it for
-     * @return The element's node
-     * @see WiredElement#getNode()
-     */
-    public static WiredNode createWiredNodeForElement(WiredElement element) {
-        return getInstance().createWiredNodeForElement(element);
-    }
-
-    /**
-     * Register a refuel handler for turtles. This may be used to provide alternative fuel sources, such as consuming RF
-     * batteries.
-     *
-     * @param handler The turtle refuel handler.
-     * @see TurtleRefuelHandler#refuel(ITurtleAccess, ItemStack, int, int)
-     */
-    public static void registerRefuelHandler(TurtleRefuelHandler handler) {
-        getInstance().registerRefuelHandler(handler);
-    }
-
-    private static ComputerCraftAPIService getInstance() {
-        return ComputerCraftAPIService.get();
-    }
-}

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

@@ -1,59 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
- * For help using the API, and posting your mods, visit the forums at computercraft.info.
- */
-package dan200.computercraft.api;
-
-import net.minecraft.core.registries.Registries;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.tags.TagKey;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.level.block.Block;
-
-/**
- * Tags provided by ComputerCraft.
- */
-public class ComputerCraftTags {
-    public static class Items {
-        public static final TagKey<Item> COMPUTER = make("computer");
-        public static final TagKey<Item> TURTLE = make("turtle");
-        public static final TagKey<Item> WIRED_MODEM = make("wired_modem");
-        public static final TagKey<Item> MONITOR = make("monitor");
-
-        private static TagKey<Item> make(String name) {
-            return TagKey.create(Registries.ITEM, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
-        }
-    }
-
-    public static class Blocks {
-        public static final TagKey<Block> COMPUTER = make("computer");
-        public static final TagKey<Block> TURTLE = make("turtle");
-        public static final TagKey<Block> WIRED_MODEM = make("wired_modem");
-        public static final TagKey<Block> MONITOR = make("monitor");
-
-        /**
-         * Blocks which can be broken by any turtle tool.
-         */
-        public static final TagKey<Block> TURTLE_ALWAYS_BREAKABLE = make("turtle_always_breakable");
-
-        /**
-         * Blocks which can be broken by the default shovel tool.
-         */
-        public static final TagKey<Block> TURTLE_SHOVEL_BREAKABLE = make("turtle_shovel_harvestable");
-
-        /**
-         * Blocks which can be broken with the default sword tool.
-         */
-        public static final TagKey<Block> TURTLE_SWORD_BREAKABLE = make("turtle_sword_harvestable");
-
-        /**
-         * Blocks which can be broken with the default hoe tool.
-         */
-        public static final TagKey<Block> TURTLE_HOE_BREAKABLE = make("turtle_hoe_harvestable");
-
-        private static TagKey<Block> make(String name) {
-            return TagKey.create(Registries.BLOCK, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
-        }
-    }
-}

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

@@ -1,171 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. This API may be redistributed unmodified and in full only.
- * For help using the API, and posting your mods, visit the forums at computercraft.info.
- */
-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 org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-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 static final Logger LOGGER = LogManager.getLogger();
-
-    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 final 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 = 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 beeen 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);
-        }
-    }
-}

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

@@ -1,84 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.impl;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.detail.BlockReference;
-import dan200.computercraft.api.detail.DetailRegistry;
-import dan200.computercraft.api.filesystem.Mount;
-import dan200.computercraft.api.filesystem.WritableMount;
-import dan200.computercraft.api.lua.GenericSource;
-import dan200.computercraft.api.lua.ILuaAPIFactory;
-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.redstone.BundledRedstoneProvider;
-import dan200.computercraft.api.turtle.TurtleRefuelHandler;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.Level;
-import org.jetbrains.annotations.ApiStatus;
-
-import javax.annotation.Nullable;
-
-/**
- * Backing interface for {@link ComputerCraftAPI}
- * <p>
- * Do <strong>NOT</strong> directly reference this class. It exists for internal use by the API.
- */
-@ApiStatus.Internal
-public interface ComputerCraftAPIService {
-    static ComputerCraftAPIService get() {
-        var instance = Instance.INSTANCE;
-        return instance == null ? Services.raise(ComputerCraftAPIService.class, Instance.ERROR) : instance;
-    }
-
-    String getInstalledVersion();
-
-    int createUniqueNumberedSaveDir(MinecraftServer server, String parentSubPath);
-
-    WritableMount createSaveDirMount(MinecraftServer server, String subPath, long capacity);
-
-    @Nullable
-    Mount createResourceMount(MinecraftServer server, String domain, String subPath);
-
-    void registerGenericSource(GenericSource source);
-
-    void registerBundledRedstoneProvider(BundledRedstoneProvider provider);
-
-    int getBundledRedstoneOutput(Level world, BlockPos pos, Direction side);
-
-    void registerMediaProvider(MediaProvider provider);
-
-    PacketNetwork getWirelessNetwork(MinecraftServer server);
-
-    void registerAPIFactory(ILuaAPIFactory factory);
-
-    WiredNode createWiredNodeForElement(WiredElement element);
-
-    void registerRefuelHandler(TurtleRefuelHandler handler);
-
-    DetailRegistry<ItemStack> getItemStackDetailRegistry();
-
-    DetailRegistry<BlockReference> getBlockInWorldDetailRegistry();
-
-    final class Instance {
-        static final @Nullable ComputerCraftAPIService INSTANCE;
-        static final @Nullable Throwable ERROR;
-
-        static {
-            var helper = Services.tryLoad(ComputerCraftAPIService.class);
-            INSTANCE = helper.instance();
-            ERROR = helper.error();
-        }
-
-        private Instance() {
-        }
-    }
-}

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

@@ -1,82 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.impl;
-
-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();
-    }
-
-    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/package-info.java

@@ -1,21 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-
-/**
- * Internal interfaces for ComputerCraft's API.
- */
-@ApiStatus.Internal
-@DefaultQualifier(value = NonNull.class, locations = {
-    TypeUseLocation.RETURN,
-    TypeUseLocation.PARAMETER,
-    TypeUseLocation.FIELD,
-})
-package dan200.computercraft.impl;
-
-import org.checkerframework.checker.nullness.qual.NonNull;
-import org.checkerframework.framework.qual.DefaultQualifier;
-import org.checkerframework.framework.qual.TypeUseLocation;
-import org.jetbrains.annotations.ApiStatus;

projects/common/build.gradle.kts

@@ -1,36 +0,0 @@
-import cc.tweaked.gradle.annotationProcessorEverywhere
-import cc.tweaked.gradle.clientClasses
-import cc.tweaked.gradle.commonClasses
-
-plugins {
-    id("cc-tweaked.vanilla")
-    id("cc-tweaked.gametest")
-}
-
-minecraft {
-    accessWideners(
-        "src/main/resources/computercraft.accesswidener",
-        "src/main/resources/computercraft-common.accesswidener",
-    )
-}
-
-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.bundles.externalMods.common)
-
-    compileOnly(libs.mixin)
-    annotationProcessorEverywhere(libs.autoService)
-    testFixturesAnnotationProcessor(libs.autoService)
-
-    testImplementation(testFixtures(project(":core")))
-    testImplementation(libs.bundles.test)
-    testRuntimeOnly(libs.bundles.testRuntime)
-
-    testModImplementation(testFixtures(project(":core")))
-    testModImplementation(testFixtures(project(":common")))
-    testModImplementation(libs.bundles.kotlin)
-}

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

@@ -1,190 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client;
-
-import com.mojang.blaze3d.audio.Channel;
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.client.pocket.ClientPocketComputers;
-import dan200.computercraft.client.render.CableHighlightRenderer;
-import dan200.computercraft.client.render.PocketItemRenderer;
-import dan200.computercraft.client.render.PrintoutItemRenderer;
-import dan200.computercraft.client.render.monitor.MonitorHighlightRenderer;
-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;
-import dan200.computercraft.shared.peripheral.modem.wired.CableShapes;
-import dan200.computercraft.shared.peripheral.monitor.MonitorBlockEntity;
-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;
-import net.minecraft.client.sounds.AudioStream;
-import net.minecraft.client.sounds.SoundEngine;
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.entity.decoration.ItemFrame;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.state.BlockState;
-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;
-
-/**
- * Event listeners for client-only code.
- * <p>
- * This is the client-only version of {@link CommonHooks}, and so should be where all client-specific event handlers are
- * defined.
- */
-public final class ClientHooks {
-    private ClientHooks() {
-    }
-
-    public static void onTick() {
-        FrameInfo.onTick();
-    }
-
-    public static void onRenderTick() {
-        PauseAwareTimer.tick(Minecraft.getInstance().isPaused());
-        FrameInfo.onRenderTick();
-    }
-
-    public static void onWorldUnload() {
-        MonitorRenderState.destroyAll();
-        SpeakerManager.reset();
-        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);
-    }
-
-    public static boolean onRenderHeldItem(
-        PoseStack transform, MultiBufferSource render, int lightTexture, InteractionHand hand,
-        float pitch, float equipProgress, float swingProgress, ItemStack stack
-    ) {
-        if (stack.getItem() instanceof PocketComputerItem) {
-            PocketItemRenderer.INSTANCE.renderItemFirstPerson(transform, render, lightTexture, hand, pitch, equipProgress, swingProgress, stack);
-            return true;
-        }
-        if (stack.getItem() instanceof PrintoutItem) {
-            PrintoutItemRenderer.INSTANCE.renderItemFirstPerson(transform, render, lightTexture, hand, pitch, equipProgress, swingProgress, stack);
-            return true;
-        }
-
-        return false;
-    }
-
-    public static boolean onRenderItemFrame(PoseStack transform, MultiBufferSource render, ItemFrame frame, ItemStack stack, int light) {
-        if (stack.getItem() instanceof PrintoutItem) {
-            PrintoutItemRenderer.onRenderInFrame(transform, render, frame, stack, light);
-            return true;
-        }
-
-        return false;
-    }
-
-    public static void onPlayStreaming(SoundEngine engine, Channel channel, AudioStream stream) {
-        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.
-     *
-     * @param addText A callback which adds a single line of text.
-     */
-    public static void addDebugInfo(Consumer<String> addText) {
-        var minecraft = Minecraft.getInstance();
-        if (!minecraft.options.renderDebug || minecraft.level == null) return;
-        if (minecraft.hitResult == null || minecraft.hitResult.getType() != HitResult.Type.BLOCK) return;
-
-        var tile = minecraft.level.getBlockEntity(((BlockHitResult) minecraft.hitResult).getBlockPos());
-
-        if (tile instanceof MonitorBlockEntity monitor) {
-            addText.accept("");
-            addText.accept(
-                String.format("Targeted monitor: (%d, %d), %d x %d", monitor.getXIndex(), monitor.getYIndex(), monitor.getWidth(), monitor.getHeight())
-            );
-        } else if (tile instanceof TurtleBlockEntity turtle) {
-            addText.accept("");
-            addText.accept("Targeted turtle:");
-            addText.accept(String.format("Id: %d", turtle.getComputerID()));
-            addTurtleUpgrade(addText, turtle, TurtleSide.LEFT);
-            addTurtleUpgrade(addText, turtle, TurtleSide.RIGHT);
-        }
-    }
-
-    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()));
-    }
-
-    public static @Nullable BlockState getBlockBreakingState(BlockState state, BlockPos pos) {
-        // Only apply to cables which have both a cable and modem
-        if (state.getBlock() != ModRegistry.Blocks.CABLE.get()
-            || !state.getValue(CableBlock.CABLE)
-            || state.getValue(CableBlock.MODEM) == CableModemVariant.None
-        ) {
-            return null;
-        }
-
-        var hit = Minecraft.getInstance().hitResult;
-        if (hit == null || hit.getType() != HitResult.Type.BLOCK) return null;
-        var hitPos = ((BlockHitResult) hit).getBlockPos();
-
-        if (!hitPos.equals(pos)) return null;
-
-        return WorldUtil.isVecInside(CableShapes.getModemShape(state), hit.getLocation().subtract(pos.getX(), pos.getY(), pos.getZ()))
-            ? state.getBlock().defaultBlockState().setValue(CableBlock.MODEM, state.getValue(CableBlock.MODEM))
-            : state.setValue(CableBlock.MODEM, CableModemVariant.None);
-    }
-}

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

@@ -1,198 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.client.ComputerCraftAPIClient;
-import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
-import dan200.computercraft.client.gui.*;
-import dan200.computercraft.client.pocket.ClientPocketComputers;
-import dan200.computercraft.client.render.RenderTypes;
-import dan200.computercraft.client.render.TurtleBlockEntityRenderer;
-import dan200.computercraft.client.render.monitor.MonitorBlockEntityRenderer;
-import dan200.computercraft.client.turtle.TurtleModemModeller;
-import dan200.computercraft.core.util.Colour;
-import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.common.IColouredItem;
-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.client.color.item.ItemColor;
-import net.minecraft.client.gui.screens.MenuScreens;
-import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.client.renderer.ShaderInstance;
-import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
-import net.minecraft.client.renderer.item.ClampedItemPropertyFunction;
-import net.minecraft.client.renderer.item.ItemProperties;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.resources.ResourceProvider;
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.ItemLike;
-import net.minecraft.world.level.block.entity.BlockEntity;
-import net.minecraft.world.level.block.entity.BlockEntityType;
-
-import javax.annotation.Nullable;
-import java.io.IOException;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-/**
- * Registers client-side objects, such as {@link BlockEntityRendererProvider}s and
- * {@link MenuScreens.ScreenConstructor}.
- * <p>
- * The functions in this class should be called from a loader-specific class.
- *
- * @see ModRegistry The common registry for actual game objects.
- */
-public final class ClientRegistry {
-    private 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());
-    }
-
-    /**
-     * Register any client-side objects which must be done on the main thread.
-     */
-    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()),
-            ModRegistry.Items.POCKET_COMPUTER_NORMAL, ModRegistry.Items.POCKET_COMPUTER_ADVANCED
-        );
-        registerItemProperty("coloured",
-            (stack, world, player, random) -> IColouredItem.getColourBasic(stack) != -1 ? 1 : 0,
-            ModRegistry.Items.POCKET_COMPUTER_NORMAL, ModRegistry.Items.POCKET_COMPUTER_ADVANCED
-        );
-    }
-
-    @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 final String[] EXTRA_MODELS = new String[]{
-        // Turtle upgrades
-        "block/turtle_modem_normal_off_left",
-        "block/turtle_modem_normal_on_left",
-        "block/turtle_modem_normal_off_right",
-        "block/turtle_modem_normal_on_right",
-
-        "block/turtle_modem_advanced_off_left",
-        "block/turtle_modem_advanced_on_left",
-        "block/turtle_modem_advanced_off_right",
-        "block/turtle_modem_advanced_on_right",
-
-        "block/turtle_crafting_table_left",
-        "block/turtle_crafting_table_right",
-
-        "block/turtle_speaker_left",
-        "block/turtle_speaker_right",
-
-        // Turtle block renderer
-        "block/turtle_colour",
-        "block/turtle_elf_overlay",
-    };
-
-    public static void registerExtraModels(Consumer<ResourceLocation> register) {
-        for (var model : EXTRA_MODELS) register.accept(new ResourceLocation(ComputerCraftAPI.MOD_ID, model));
-    }
-
-    public static void registerItemColours(BiConsumer<ItemColor, ItemLike> register) {
-        register.accept(
-            (stack, layer) -> layer == 1 ? ((DiskItem) stack.getItem()).getColour(stack) : 0xFFFFFF,
-            ModRegistry.Items.DISK.get()
-        );
-
-        register.accept(
-            (stack, layer) -> layer == 1 ? TreasureDiskItem.getColour(stack) : 0xFFFFFF,
-            ModRegistry.Items.TREASURE_DISK.get()
-        );
-
-        register.accept(ClientRegistry::getPocketColour, ModRegistry.Items.POCKET_COMPUTER_NORMAL.get());
-        register.accept(ClientRegistry::getPocketColour, ModRegistry.Items.POCKET_COMPUTER_ADVANCED.get());
-
-        register.accept(ClientRegistry::getTurtleColour, ModRegistry.Blocks.TURTLE_NORMAL.get());
-        register.accept(ClientRegistry::getTurtleColour, ModRegistry.Blocks.TURTLE_ADVANCED.get());
-    }
-
-    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;
-            }
-        }
-    }
-
-    private static int getTurtleColour(ItemStack stack, int layer) {
-        return layer == 0 ? ((IColouredItem) stack.getItem()).getColour(stack) : 0xFFFFFF;
-    }
-
-    public static void registerBlockEntityRenderers(BlockEntityRenderRegistry register) {
-        register.register(ModRegistry.BlockEntities.MONITOR_NORMAL.get(), MonitorBlockEntityRenderer::new);
-        register.register(ModRegistry.BlockEntities.MONITOR_ADVANCED.get(), MonitorBlockEntityRenderer::new);
-        register.register(ModRegistry.BlockEntities.TURTLE_NORMAL.get(), TurtleBlockEntityRenderer::new);
-        register.register(ModRegistry.BlockEntities.TURTLE_ADVANCED.get(), TurtleBlockEntityRenderer::new);
-    }
-
-    public interface BlockEntityRenderRegistry {
-        <T extends BlockEntity> void register(BlockEntityType<? extends T> type, BlockEntityRendererProvider<T> provider);
-    }
-
-    public static void registerShaders(ResourceProvider resources, BiConsumer<ShaderInstance, Consumer<ShaderInstance>> load) throws IOException {
-        RenderTypes.registerShaders(resources, load);
-    }
-
-    private record UnclampedPropertyFunction(
-        ClampedItemPropertyFunction function
-    ) implements ClampedItemPropertyFunction {
-        @Override
-        public float unclampedCall(ItemStack stack, @Nullable ClientLevel level, @Nullable LivingEntity entity, int layer) {
-            return function.unclampedCall(stack, level, entity, layer);
-        }
-
-        @Deprecated
-        @Override
-        public float call(ItemStack stack, @Nullable ClientLevel level, @Nullable LivingEntity entity, int layer) {
-            return function.unclampedCall(stack, level, entity, layer);
-        }
-    }
-}

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

@@ -1,81 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client;
-
-import dan200.computercraft.shared.command.text.ChatHelpers;
-import dan200.computercraft.shared.command.text.TableBuilder;
-import dan200.computercraft.shared.command.text.TableFormatter;
-import net.minecraft.ChatFormatting;
-import net.minecraft.client.GuiMessageTag;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.Font;
-import net.minecraft.network.chat.Component;
-import net.minecraft.util.Mth;
-import org.apache.commons.lang3.StringUtils;
-
-import javax.annotation.Nullable;
-import java.util.Objects;
-
-public class ClientTableFormatter implements TableFormatter {
-    public static final ClientTableFormatter INSTANCE = new ClientTableFormatter();
-
-    private static Font renderer() {
-        return Minecraft.getInstance().font;
-    }
-
-    @Override
-    @Nullable
-    public Component getPadding(Component component, int width) {
-        var extraWidth = width - getWidth(component);
-        if (extraWidth <= 0) return null;
-
-        var renderer = renderer();
-
-        float spaceWidth = renderer.width(" ");
-        var spaces = Mth.floor(extraWidth / spaceWidth);
-        var extra = extraWidth - (int) (spaces * spaceWidth);
-
-        return ChatHelpers.coloured(StringUtils.repeat(' ', spaces) + StringUtils.repeat((char) 712, extra), ChatFormatting.GRAY);
-    }
-
-    @Override
-    public int getColumnPadding() {
-        return 3;
-    }
-
-    @Override
-    public int getWidth(Component component) {
-        return renderer().width(component);
-    }
-
-    @Override
-    public void writeLine(String label, Component component) {
-        var mc = Minecraft.getInstance();
-        var chat = mc.gui.getChat();
-
-        // TODO: Trim the text if it goes over the allowed length
-        // int maxWidth = MathHelper.floor( chat.getChatWidth() / chat.getScale() );
-        // List<ITextProperties> list = RenderComponentsUtil.wrapComponents( component, maxWidth, mc.fontRenderer );
-        // if( !list.isEmpty() ) chat.printChatMessageWithOptionalDeletion( list.get( 0 ), id );
-        chat.addMessage(component, null, createTag(label));
-    }
-
-    @Override
-    public void display(TableBuilder table) {
-        var chat = Minecraft.getInstance().gui.getChat();
-
-        var tag = createTag(table.getId());
-        if (chat.allMessages.removeIf(guiMessage -> guiMessage.tag() != null && Objects.equals(guiMessage.tag().logTag(), tag.logTag()))) {
-            chat.refreshTrimmedMessage();
-        }
-
-        TableFormatter.super.display(table);
-    }
-
-    private static GuiMessageTag createTag(String id) {
-        return new GuiMessageTag(0xa0a0a0, null, null, "ComputerCraft/" + id);
-    }
-}

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

@@ -1,30 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client;
-
-public final class FrameInfo {
-    private static int tick;
-    private static long renderFrame;
-
-    private FrameInfo() {
-    }
-
-    public static boolean getGlobalCursorBlink() {
-        return (tick / 8) % 2 == 0;
-    }
-
-    public static long getRenderFrame() {
-        return renderFrame;
-    }
-
-    public static void onTick() {
-        tick++;
-    }
-
-    public static void onRenderTick() {
-        renderFrame++;
-    }
-}

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

@@ -1,219 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-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.core.terminal.Terminal;
-import dan200.computercraft.shared.computer.core.ComputerFamily;
-import dan200.computercraft.shared.computer.core.InputHandler;
-import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
-import dan200.computercraft.shared.computer.upload.FileUpload;
-import dan200.computercraft.shared.computer.upload.UploadResult;
-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.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.world.item.ItemStack;
-import org.lwjgl.glfw.GLFW;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.annotation.Nullable;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-import static dan200.computercraft.core.util.Nullability.assertNonNull;
-
-public abstract class AbstractComputerScreen<T extends AbstractComputerMenu> extends AbstractContainerScreen<T> {
-    private static final Logger LOG = LoggerFactory.getLogger(AbstractComputerScreen.class);
-
-    private static final Component OK = Component.translatable("gui.ok");
-    private static final Component NO_RESPONSE_TITLE = Component.translatable("gui.computercraft.upload.no_response");
-    private static final Component NO_RESPONSE_MSG = Component.translatable("gui.computercraft.upload.no_response.msg",
-        Component.literal("import").withStyle(ChatFormatting.DARK_GRAY));
-
-    protected @Nullable TerminalWidget terminal;
-    protected Terminal terminalData;
-    protected final ComputerFamily family;
-    protected final InputHandler input;
-
-    protected final int sidebarYOffset;
-
-    private long uploadNagDeadline = Long.MAX_VALUE;
-    private final ItemStack displayStack;
-
-    public AbstractComputerScreen(T container, Inventory player, Component title, int sidebarYOffset) {
-        super(container, player, title);
-        terminalData = container.getTerminal();
-        family = container.getFamily();
-        displayStack = container.getDisplayStack();
-        input = new ClientInputHandler(menu);
-        this.sidebarYOffset = sidebarYOffset;
-    }
-
-    protected abstract TerminalWidget createTerminal();
-
-    protected final TerminalWidget getTerminal() {
-        if (terminal == null) throw new IllegalStateException("Screen has not been initialised yet");
-        return terminal;
-    }
-
-    @Override
-    protected void init() {
-        super.init();
-
-        terminal = addRenderableWidget(createTerminal());
-        ComputerSidebar.addButtons(menu::isOn, input, this::addRenderableWidget, leftPos, topPos + sidebarYOffset);
-        setFocused(terminal);
-    }
-
-    @Override
-    public void containerTick() {
-        super.containerTick();
-        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());
-            uploadNagDeadline = Long.MAX_VALUE;
-        }
-    }
-
-    @Override
-    public boolean keyPressed(int key, int scancode, int modifiers) {
-        // Forward the tab key to the terminal, rather than moving between controls.
-        if (key == GLFW.GLFW_KEY_TAB && getFocused() != null && getFocused() == terminal) {
-            return getFocused().keyPressed(key, scancode, modifiers);
-        }
-
-        return super.keyPressed(key, scancode, modifiers);
-    }
-
-    @Override
-    public boolean mouseReleased(double x, double y, int button) {
-        // Reimplement ContainerEventHandler.mouseReleased, as it's not called in vanilla (it is in Forge, but that
-        // shouldn't matter).
-        setDragging(false);
-        var child = getChildAt(x, y);
-        if (child.isPresent() && child.get().mouseReleased(x, y, button)) return true;
-
-        return super.mouseReleased(x, y, button);
-    }
-
-    @Override
-    public void render(PoseStack stack, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(stack);
-        super.render(stack, mouseX, mouseY, partialTicks);
-        renderTooltip(stack, mouseX, mouseY);
-    }
-
-    @Override
-    public boolean mouseClicked(double x, double y, int button) {
-        var changed = super.mouseClicked(x, y, button);
-        // Clicking the terminate/shutdown button steals focus, which means then pressing "enter" will click the button
-        // again. Restore the focus to the terminal in these cases.
-        if (getFocused() instanceof DynamicImageButton) setFocused(terminal);
-        return changed;
-    }
-
-    @Override
-    public boolean mouseDragged(double x, double y, int button, double deltaX, double deltaY) {
-        return (getFocused() != null && getFocused().mouseDragged(x, y, button, deltaX, deltaY))
-            || super.mouseDragged(x, y, button, deltaX, deltaY);
-    }
-
-
-    @Override
-    protected void renderLabels(PoseStack transform, int mouseX, int mouseY) {
-        // Skip rendering labels.
-    }
-
-    @Override
-    public void onFilesDrop(List<Path> files) {
-        if (files.isEmpty()) return;
-
-        if (!menu.isOn()) {
-            alert(UploadResult.FAILED_TITLE, UploadResult.COMPUTER_OFF_MSG);
-            return;
-        }
-
-        long size = 0;
-
-        List<FileUpload> toUpload = new ArrayList<>();
-        for (var file : files) {
-            // TODO: Recurse directories? If so, we probably want to shunt this off-thread.
-            if (!Files.isRegularFile(file)) continue;
-
-            try (var sbc = Files.newByteChannel(file)) {
-                var fileSize = sbc.size();
-                if (fileSize > UploadFileMessage.MAX_SIZE || (size += fileSize) >= UploadFileMessage.MAX_SIZE) {
-                    alert(UploadResult.FAILED_TITLE, UploadResult.TOO_MUCH_MSG);
-                    return;
-                }
-
-                var name = file.getFileName().toString();
-                if (name.length() > UploadFileMessage.MAX_FILE_NAME) {
-                    alert(UploadResult.FAILED_TITLE, Component.translatable("gui.computercraft.upload.failed.name_too_long"));
-                    return;
-                }
-
-                var buffer = ByteBuffer.allocateDirect((int) fileSize);
-                sbc.read(buffer);
-                buffer.flip();
-
-                var digest = FileUpload.getDigest(buffer);
-                if (digest == null) {
-                    alert(UploadResult.FAILED_TITLE, Component.translatable("gui.computercraft.upload.failed.corrupted"));
-                    return;
-                }
-
-                toUpload.add(new FileUpload(name, buffer, digest));
-            } catch (IOException e) {
-                LOG.error("Failed uploading files", e);
-                alert(UploadResult.FAILED_TITLE, Component.translatable("gui.computercraft.upload.failed.generic", "Cannot compute checksum"));
-            }
-        }
-
-        if (toUpload.size() > UploadFileMessage.MAX_FILES) {
-            alert(UploadResult.FAILED_TITLE, Component.translatable("gui.computercraft.upload.failed.too_many_files"));
-            return;
-        }
-
-        if (toUpload.size() > 0) UploadFileMessage.send(menu, toUpload, ClientPlatformHelper.get()::sendToServer);
-    }
-
-    public void uploadResult(UploadResult result, @Nullable Component message) {
-        switch (result) {
-            case QUEUED -> {
-                if (Config.uploadNagDelay > 0) {
-                    uploadNagDeadline = Util.getNanos() + TimeUnit.SECONDS.toNanos(Config.uploadNagDelay);
-                }
-            }
-            case CONSUMED -> uploadNagDeadline = Long.MAX_VALUE;
-            case ERROR -> alert(UploadResult.FAILED_TITLE, assertNonNull(message));
-        }
-    }
-
-    private void alert(Component title, Component message) {
-        OptionScreen.show(minecraft, title, message,
-            Collections.singletonList(OptionScreen.newButton(OK, b -> minecraft.setScreen(this))),
-            () -> minecraft.setScreen(this)
-        );
-    }
-}

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

@@ -1,80 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import dan200.computercraft.client.platform.ClientPlatformHelper;
-import dan200.computercraft.shared.computer.core.InputHandler;
-import dan200.computercraft.shared.computer.menu.ComputerMenu;
-import dan200.computercraft.shared.network.server.ComputerActionServerMessage;
-import dan200.computercraft.shared.network.server.KeyEventServerMessage;
-import dan200.computercraft.shared.network.server.MouseEventServerMessage;
-import dan200.computercraft.shared.network.server.QueueEventServerMessage;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-
-import javax.annotation.Nullable;
-
-/**
- * An {@link InputHandler} which for use on the client.
- * <p>
- * This queues events on the remote player's open {@link ComputerMenu}
- */
-public final class ClientInputHandler implements InputHandler {
-    private final AbstractContainerMenu menu;
-
-    public ClientInputHandler(AbstractContainerMenu menu) {
-        this.menu = menu;
-    }
-
-    @Override
-    public void turnOn() {
-        ClientPlatformHelper.get().sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.TURN_ON));
-    }
-
-    @Override
-    public void shutdown() {
-        ClientPlatformHelper.get().sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.SHUTDOWN));
-    }
-
-    @Override
-    public void reboot() {
-        ClientPlatformHelper.get().sendToServer(new ComputerActionServerMessage(menu, ComputerActionServerMessage.Action.REBOOT));
-    }
-
-    @Override
-    public void queueEvent(String event, @Nullable Object[] arguments) {
-        ClientPlatformHelper.get().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));
-    }
-
-    @Override
-    public void keyUp(int key) {
-        ClientPlatformHelper.get().sendToServer(new KeyEventServerMessage(menu, KeyEventServerMessage.TYPE_UP, key));
-    }
-
-    @Override
-    public void mouseClick(int button, int x, int y) {
-        ClientPlatformHelper.get().sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.TYPE_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));
-    }
-
-    @Override
-    public void mouseDrag(int button, int x, int y) {
-        ClientPlatformHelper.get().sendToServer(new MouseEventServerMessage(menu, MouseEventServerMessage.TYPE_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));
-    }
-}

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

@@ -1,42 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.client.gui.widgets.ComputerSidebar;
-import dan200.computercraft.client.gui.widgets.TerminalWidget;
-import dan200.computercraft.client.render.ComputerBorderRenderer;
-import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.player.Inventory;
-
-import static dan200.computercraft.client.render.ComputerBorderRenderer.BORDER;
-import static dan200.computercraft.client.render.RenderTypes.FULL_BRIGHT_LIGHTMAP;
-
-public final class ComputerScreen<T extends AbstractComputerMenu> extends AbstractComputerScreen<T> {
-    public ComputerScreen(T container, Inventory player, Component title) {
-        super(container, player, title, BORDER);
-
-        imageWidth = TerminalWidget.getWidth(terminalData.getWidth()) + BORDER * 2 + AbstractComputerMenu.SIDEBAR_WIDTH;
-        imageHeight = TerminalWidget.getHeight(terminalData.getHeight()) + BORDER * 2;
-    }
-
-    @Override
-    protected TerminalWidget createTerminal() {
-        return new TerminalWidget(terminalData, input, leftPos + AbstractComputerMenu.SIDEBAR_WIDTH + BORDER, topPos + BORDER);
-    }
-
-    @Override
-    public void renderBg(PoseStack stack, float partialTicks, int mouseX, int mouseY) {
-        // Draw a border around the terminal
-        var terminal = getTerminal();
-        ComputerBorderRenderer.render(
-            stack.last().pose(), ComputerBorderRenderer.getTexture(family), terminal.getX(), terminal.getY(), getBlitOffset(),
-            FULL_BRIGHT_LIGHTMAP, terminal.getWidth(), terminal.getHeight()
-        );
-        ComputerSidebar.renderBackground(stack, leftPos, topPos + sidebarYOffset);
-    }
-}

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

@@ -1,37 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.shared.peripheral.diskdrive.DiskDriveMenu;
-import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Inventory;
-
-
-public class DiskDriveScreen extends AbstractContainerScreen<DiskDriveMenu> {
-    private static final ResourceLocation BACKGROUND = new ResourceLocation("computercraft", "textures/gui/disk_drive.png");
-
-    public DiskDriveScreen(DiskDriveMenu container, Inventory player, Component title) {
-        super(container, player, title);
-    }
-
-    @Override
-    protected void renderBg(PoseStack transform, float partialTicks, int mouseX, int mouseY) {
-        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
-        RenderSystem.setShaderTexture(0, BACKGROUND);
-        blit(transform, leftPos, topPos, 0, 0, imageWidth, imageHeight);
-    }
-
-    @Override
-    public void render(PoseStack transform, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(transform);
-        super.render(transform, mouseX, mouseY, partialTicks);
-        renderTooltip(transform, mouseX, mouseY);
-    }
-}

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

@@ -1,127 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.Minecraft;
-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.util.FormattedCharSequence;
-import net.minecraft.world.item.ItemStack;
-
-import java.util.List;
-
-/**
- * A {@link Toast} implementation which displays an arbitrary message along with an optional {@link ItemStack}.
- */
-public class ItemToast implements Toast {
-    public static final Object TRANSFER_NO_RESPONSE_TOKEN = new Object();
-
-    private static final long DISPLAY_TIME = 7000L;
-    private static final int MAX_LINE_SIZE = 200;
-
-    private static final int IMAGE_SIZE = 16;
-    private static final int LINE_SPACING = 10;
-    private static final int MARGIN = 8;
-
-    private final ItemStack stack;
-    private final Component title;
-    private final List<FormattedCharSequence> message;
-    private final Object token;
-    private final int width;
-
-    private boolean isNew = true;
-    private long firstDisplay;
-
-    public ItemToast(Minecraft minecraft, ItemStack stack, Component title, Component message, Object token) {
-        this.stack = stack;
-        this.title = title;
-        this.token = token;
-
-        var font = minecraft.font;
-        this.message = font.split(message, MAX_LINE_SIZE);
-        width = Math.max(MAX_LINE_SIZE, this.message.stream().mapToInt(font::width).max().orElse(MAX_LINE_SIZE)) + MARGIN * 3 + IMAGE_SIZE;
-    }
-
-    public void showOrReplace(ToastComponent toasts) {
-        var existing = toasts.getToast(ItemToast.class, getToken());
-        if (existing != null) {
-            existing.isNew = true;
-        } else {
-            toasts.addToast(this);
-        }
-    }
-
-    @Override
-    public int width() {
-        return width;
-    }
-
-    @Override
-    public int height() {
-        return MARGIN * 2 + LINE_SPACING + message.size() * LINE_SPACING;
-    }
-
-    @Override
-    public Object getToken() {
-        return token;
-    }
-
-    @Override
-    public Visibility render(PoseStack transform, ToastComponent component, long time) {
-        if (isNew) {
-
-            firstDisplay = time;
-            isNew = false;
-        }
-
-        RenderSystem.setShaderTexture(0, TEXTURE);
-        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
-
-        if (width == 160 && message.size() <= 1) {
-            component.blit(transform, 0, 0, 0, 64, width, height());
-        } else {
-
-            var height = height();
-
-            var bottom = Math.min(4, height - 28);
-            renderBackgroundRow(transform, component, width, 0, 0, 28);
-
-            for (var i = 28; i < height - bottom; i += 10) {
-                renderBackgroundRow(transform, component, width, 16, i, Math.min(16, height - i - bottom));
-            }
-
-            renderBackgroundRow(transform, component, width, 32 - bottom, height - bottom, bottom);
-        }
-
-        var textX = MARGIN;
-        if (!stack.isEmpty()) {
-            textX += MARGIN + IMAGE_SIZE;
-            component.getMinecraft().getItemRenderer().renderAndDecorateFakeItem(stack, MARGIN, MARGIN + height() / 2 - IMAGE_SIZE);
-        }
-
-        component.getMinecraft().font.draw(transform, title, textX, MARGIN, 0xff500050);
-        for (var i = 0; i < message.size(); ++i) {
-            component.getMinecraft().font.draw(transform, message.get(i), textX, (float) (LINE_SPACING + (i + 1) * LINE_SPACING), 0xff000000);
-        }
-
-        return time - firstDisplay < DISPLAY_TIME ? Visibility.SHOW : Visibility.HIDE;
-    }
-
-    private static void renderBackgroundRow(PoseStack transform, ToastComponent component, int x, int u, int y, int height) {
-        var leftOffset = 5;
-        var rightOffset = Math.min(60, x - leftOffset);
-
-        component.blit(transform, 0, y, 0, 32 + u, leftOffset, height);
-        for (var k = leftOffset; k < x - rightOffset; k += 64) {
-            component.blit(transform, k, y, 32, 32 + u, Math.min(64, x - k - rightOffset), height);
-        }
-
-        component.blit(transform, x - rightOffset, y, 160 - rightOffset, 32 + u, rightOffset, height);
-    }
-}

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

@@ -1,101 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.client.gui.widgets.TerminalWidget;
-import dan200.computercraft.core.terminal.Terminal;
-import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
-import net.minecraft.client.KeyMapping;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.client.gui.screens.inventory.MenuAccess;
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.player.Inventory;
-import org.lwjgl.glfw.GLFW;
-
-import javax.annotation.Nullable;
-
-import static dan200.computercraft.core.util.Nullability.assertNonNull;
-
-public class NoTermComputerScreen<T extends AbstractComputerMenu> extends Screen implements MenuAccess<T> {
-    private final T menu;
-    private final Terminal terminalData;
-    private @Nullable TerminalWidget terminal;
-
-    public NoTermComputerScreen(T menu, Inventory player, Component title) {
-        super(title);
-        this.menu = menu;
-        terminalData = menu.getTerminal();
-    }
-
-    @Override
-    public T getMenu() {
-        return menu;
-    }
-
-    @Override
-    protected void init() {
-        passEvents = true; // Pass mouse vents through to the game's mouse handler.
-        // 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;
-        KeyMapping.releaseAll();
-
-        super.init();
-
-        terminal = addWidget(new TerminalWidget(terminalData, new ClientInputHandler(menu), 0, 0));
-        terminal.visible = false;
-        terminal.active = false;
-        setFocused(terminal);
-    }
-
-    @Override
-    public final void tick() {
-        super.tick();
-        assertNonNull(terminal).update();
-    }
-
-    @Override
-    public boolean mouseScrolled(double pMouseX, double pMouseY, double pDelta) {
-        minecraft.player.getInventory().swapPaint(pDelta);
-        return super.mouseScrolled(pMouseX, pMouseY, pDelta);
-    }
-
-    @Override
-    public void onClose() {
-        minecraft.player.closeContainer();
-        super.onClose();
-    }
-
-    @Override
-    public boolean isPauseScreen() {
-        return false;
-    }
-
-    @Override
-    public final boolean keyPressed(int key, int scancode, int modifiers) {
-        // Forward the tab key to the terminal, rather than moving between controls.
-        if (key == GLFW.GLFW_KEY_TAB && getFocused() != null && getFocused() == terminal) {
-            return getFocused().keyPressed(key, scancode, modifiers);
-        }
-
-        return super.keyPressed(key, scancode, modifiers);
-    }
-
-    @Override
-    public void render(PoseStack transform, int mouseX, int mouseY, float partialTicks) {
-        super.render(transform, mouseX, mouseY, partialTicks);
-
-        var font = minecraft.font;
-        var lines = font.split(Component.translatable("gui.computercraft.pocket_computer_overlay"), (int) (width * 0.8));
-        var y = 10.0f;
-        for (var line : lines) {
-            font.drawShadow(transform, line, (float) ((width / 2) - (minecraft.font.width(line) / 2)), y, 0xFFFFFF);
-            y += 9.0f;
-        }
-    }
-}

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

@@ -1,113 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.components.AbstractWidget;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.client.gui.components.MultiLineLabel;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-
-import javax.annotation.Nullable;
-import java.util.List;
-
-import static dan200.computercraft.core.util.Nullability.assertNonNull;
-
-public final class OptionScreen extends Screen {
-    private static final ResourceLocation BACKGROUND = new ResourceLocation("computercraft", "textures/gui/blank_screen.png");
-
-    public static final int BUTTON_WIDTH = 100;
-    public static final int BUTTON_HEIGHT = 20;
-
-    private static final int PADDING = 16;
-    private static final int FONT_HEIGHT = 9;
-
-    private int x;
-    private int y;
-    private int innerWidth;
-    private int innerHeight;
-
-    private @Nullable MultiLineLabel messageRenderer;
-    private final Component message;
-    private final List<AbstractWidget> buttons;
-    private final Runnable exit;
-
-    private final Screen originalScreen;
-
-    private OptionScreen(Component title, Component message, List<AbstractWidget> buttons, Runnable exit, Screen originalScreen) {
-        super(title);
-        this.message = message;
-        this.buttons = buttons;
-        this.exit = exit;
-        this.originalScreen = originalScreen;
-    }
-
-    public static void show(Minecraft minecraft, Component title, Component message, List<AbstractWidget> buttons, Runnable exit) {
-        minecraft.setScreen(new OptionScreen(title, message, buttons, exit, unwrap(minecraft.screen)));
-    }
-
-    public static Screen unwrap(Screen screen) {
-        return screen instanceof OptionScreen option ? option.getOriginalScreen() : screen;
-    }
-
-    @Override
-    public void init() {
-        super.init();
-
-        var buttonWidth = BUTTON_WIDTH * buttons.size() + PADDING * (buttons.size() - 1);
-        var innerWidth = this.innerWidth = Math.max(256, buttonWidth + PADDING * 2);
-
-        messageRenderer = MultiLineLabel.create(font, message, innerWidth - PADDING * 2);
-
-        var textHeight = messageRenderer.getLineCount() * FONT_HEIGHT + PADDING * 2;
-        innerHeight = textHeight + (buttons.isEmpty() ? 0 : buttons.get(0).getHeight()) + PADDING;
-
-        x = (width - innerWidth) / 2;
-        y = (height - innerHeight) / 2;
-
-        var x = (width - buttonWidth) / 2;
-        for (var button : buttons) {
-            button.setPosition(x, y + textHeight);
-            addRenderableWidget(button);
-
-            x += BUTTON_WIDTH + PADDING;
-        }
-    }
-
-    @Override
-    public void render(PoseStack transform, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(transform);
-
-        // Render the actual texture.
-        RenderSystem.setShaderTexture(0, BACKGROUND);
-        blit(transform, x, y, 0, 0, innerWidth, PADDING);
-        blit(transform,
-            x, y + PADDING, 0, PADDING, innerWidth, innerHeight - PADDING * 2,
-            innerWidth, PADDING
-        );
-        blit(transform, x, y + innerHeight - PADDING, 0, 256 - PADDING, innerWidth, PADDING);
-
-        assertNonNull(messageRenderer).renderLeftAlignedNoShadow(transform, x + PADDING, y + PADDING, FONT_HEIGHT, 0x404040);
-        super.render(transform, mouseX, mouseY, partialTicks);
-    }
-
-    @Override
-    public void onClose() {
-        exit.run();
-    }
-
-    public static AbstractWidget newButton(Component component, Button.OnPress clicked) {
-        return Button.builder(component, clicked).bounds(0, 0, BUTTON_WIDTH, BUTTON_HEIGHT).build();
-    }
-
-    public Screen getOriginalScreen() {
-        return originalScreen;
-    }
-}

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

@@ -1,39 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.shared.peripheral.printer.PrinterMenu;
-import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Inventory;
-
-
-public class PrinterScreen extends AbstractContainerScreen<PrinterMenu> {
-    private static final ResourceLocation BACKGROUND = new ResourceLocation("computercraft", "textures/gui/printer.png");
-
-    public PrinterScreen(PrinterMenu container, Inventory player, Component title) {
-        super(container, player, title);
-    }
-
-    @Override
-    protected void renderBg(PoseStack transform, float partialTicks, int mouseX, int mouseY) {
-        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
-        RenderSystem.setShaderTexture(0, BACKGROUND);
-        blit(transform, leftPos, topPos, 0, 0, imageWidth, imageHeight);
-
-        if (getMenu().isPrinting()) blit(transform, leftPos + 34, topPos + 21, 176, 0, 25, 45);
-    }
-
-    @Override
-    public void render(PoseStack stack, int mouseX, int mouseY, float partialTicks) {
-        renderBackground(stack);
-        super.render(stack, mouseX, mouseY, partialTicks);
-        renderTooltip(stack, mouseX, mouseY);
-    }
-}

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

@@ -1,109 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.Tesselator;
-import dan200.computercraft.core.terminal.TextBuffer;
-import dan200.computercraft.shared.common.HeldItemMenu;
-import dan200.computercraft.shared.media.items.PrintoutItem;
-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;
-
-import static dan200.computercraft.client.render.PrintoutRenderer.*;
-import static dan200.computercraft.client.render.RenderTypes.FULL_BRIGHT_LIGHTMAP;
-
-public class PrintoutScreen extends AbstractContainerScreen<HeldItemMenu> {
-    private final boolean book;
-    private final int pages;
-    private final TextBuffer[] text;
-    private final TextBuffer[] colours;
-    private int page;
-
-    public PrintoutScreen(HeldItemMenu container, Inventory player, Component title) {
-        super(container, player, title);
-
-        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]);
-
-        page = 0;
-        pages = Math.max(this.text.length / PrintoutItem.LINES_PER_PAGE, 1);
-        book = ((PrintoutItem) container.getStack().getItem()).getType() == PrintoutItem.Type.BOOK;
-    }
-
-    @Override
-    public boolean keyPressed(int key, int scancode, int modifiers) {
-        if (super.keyPressed(key, scancode, modifiers)) return true;
-
-        if (key == GLFW.GLFW_KEY_RIGHT) {
-            if (page < pages - 1) page++;
-            return true;
-        }
-
-        if (key == GLFW.GLFW_KEY_LEFT) {
-            if (page > 0) page--;
-            return true;
-        }
-
-        return false;
-    }
-
-    @Override
-    public boolean mouseScrolled(double x, double y, double delta) {
-        if (super.mouseScrolled(x, y, delta)) return true;
-        if (delta < 0) {
-            // Scroll up goes to the next page
-            if (page < pages - 1) page++;
-            return true;
-        }
-
-        if (delta > 0) {
-            // Scroll down goes to the previous page
-            if (page > 0) page--;
-            return true;
-        }
-
-        return false;
-    }
-
-    @Override
-    protected void renderBg(PoseStack transform, float partialTicks, int mouseX, int mouseY) {
-        // Draw the printout
-        RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 1.0f);
-        RenderSystem.enableDepthTest();
-
-        var renderer = MultiBufferSource.immediate(Tesselator.getInstance().getBuilder());
-        drawBorder(transform, renderer, leftPos, topPos, getBlitOffset(), page, pages, book, FULL_BRIGHT_LIGHTMAP);
-        drawText(transform, 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(PoseStack stack, int mouseX, int mouseY, float partialTicks) {
-        // We must take the background further back in order to not overlap with our printed pages.
-        setBlitOffset(getBlitOffset() - 1);
-        renderBackground(stack);
-        setBlitOffset(getBlitOffset() + 1);
-
-        super.render(stack, mouseX, mouseY, partialTicks);
-    }
-
-    @Override
-    protected void renderLabels(PoseStack transform, int mouseX, int mouseY) {
-        // Skip rendering labels.
-    }
-}

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

@@ -1,62 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.client.gui.widgets.ComputerSidebar;
-import dan200.computercraft.client.gui.widgets.TerminalWidget;
-import dan200.computercraft.client.render.ComputerBorderRenderer;
-import dan200.computercraft.shared.computer.core.ComputerFamily;
-import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
-import dan200.computercraft.shared.turtle.inventory.TurtleMenu;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Inventory;
-
-import static dan200.computercraft.shared.turtle.inventory.TurtleMenu.*;
-
-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 int TEX_WIDTH = 254;
-    private static final int TEX_HEIGHT = 217;
-
-    public TurtleScreen(TurtleMenu container, Inventory player, Component title) {
-        super(container, player, title, BORDER);
-
-        imageWidth = TEX_WIDTH + AbstractComputerMenu.SIDEBAR_WIDTH;
-        imageHeight = TEX_HEIGHT;
-    }
-
-    @Override
-    protected TerminalWidget createTerminal() {
-        return new TerminalWidget(terminalData, input, leftPos + BORDER + AbstractComputerMenu.SIDEBAR_WIDTH, topPos + BORDER);
-    }
-
-    @Override
-    protected void renderBg(PoseStack transform, float partialTicks, int mouseX, int mouseY) {
-        var advanced = family == ComputerFamily.ADVANCED;
-        RenderSystem.setShaderTexture(0, advanced ? BACKGROUND_ADVANCED : BACKGROUND_NORMAL);
-        blit(transform, leftPos + AbstractComputerMenu.SIDEBAR_WIDTH, topPos, 0, 0, TEX_WIDTH, TEX_HEIGHT);
-
-        var slot = getMenu().getSelectedSlot();
-        if (slot >= 0) {
-            RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
-            var slotX = slot % 4;
-            var slotY = slot / 4;
-            blit(transform,
-                leftPos + TURTLE_START_X - 2 + slotX * 18, topPos + PLAYER_START_Y - 2 + slotY * 18,
-                0, 217, 24, 24
-            );
-        }
-
-        RenderSystem.setShaderTexture(0, advanced ? ComputerBorderRenderer.BACKGROUND_ADVANCED : ComputerBorderRenderer.BACKGROUND_NORMAL);
-        ComputerSidebar.renderBackground(transform, leftPos, topPos + sidebarYOffset);
-    }
-}

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

@@ -1,97 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui.widgets;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.client.gui.widgets.DynamicImageButton.HintedMessage;
-import dan200.computercraft.client.render.ComputerBorderRenderer;
-import dan200.computercraft.shared.computer.core.InputHandler;
-import dan200.computercraft.shared.computer.inventory.AbstractComputerMenu;
-import net.minecraft.client.gui.components.AbstractWidget;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-
-import java.util.function.BooleanSupplier;
-import java.util.function.Consumer;
-
-/**
- * Registers buttons to interact with a computer.
- */
-public final class ComputerSidebar {
-    private static final ResourceLocation TEXTURE = new ResourceLocation(ComputerCraftAPI.MOD_ID, "textures/gui/buttons.png");
-
-    private static final int TEX_SIZE = 64;
-
-    private static final int ICON_WIDTH = 12;
-    private static final int ICON_HEIGHT = 12;
-    private static final int ICON_MARGIN = 2;
-
-    private static final int ICON_TEX_Y_DIFF = 14;
-
-    private static final int CORNERS_BORDER = 3;
-    private static final int FULL_BORDER = CORNERS_BORDER + ICON_MARGIN;
-
-    private static final int BUTTONS = 2;
-    private static final int HEIGHT = (ICON_HEIGHT + ICON_MARGIN * 2) * BUTTONS + CORNERS_BORDER * 2;
-
-    private ComputerSidebar() {
-    }
-
-    public static void addButtons(BooleanSupplier isOn, InputHandler input, Consumer<AbstractWidget> add, int x, int y) {
-        x += CORNERS_BORDER + 1;
-        y += CORNERS_BORDER + ICON_MARGIN;
-
-        var turnOn = new HintedMessage(
-            Component.translatable("gui.computercraft.tooltip.turn_off"),
-            Component.translatable("gui.computercraft.tooltip.turn_off.key")
-        );
-        var turnOff = new HintedMessage(Component.translatable("gui.computercraft.tooltip.turn_on"), (Component) null);
-        add.accept(new DynamicImageButton(
-            x, y, ICON_WIDTH, ICON_HEIGHT, () -> isOn.getAsBoolean() ? 15 : 1, 1, ICON_TEX_Y_DIFF,
-            TEXTURE, TEX_SIZE, TEX_SIZE, b -> toggleComputer(isOn, input),
-            () -> isOn.getAsBoolean() ? turnOff : turnOn
-        ));
-
-        y += ICON_HEIGHT + ICON_MARGIN * 2;
-
-        add.accept(new DynamicImageButton(
-            x, y, ICON_WIDTH, ICON_HEIGHT, 29, 1, ICON_TEX_Y_DIFF,
-            TEXTURE, TEX_SIZE, TEX_SIZE, b -> input.queueEvent("terminate"),
-            new HintedMessage(
-                Component.translatable("gui.computercraft.tooltip.terminate"),
-                Component.translatable("gui.computercraft.tooltip.terminate.key")
-            )
-        ));
-    }
-
-    public static void renderBackground(PoseStack transform, int x, int y) {
-        Screen.blit(transform,
-            x, y, 0, 102, AbstractComputerMenu.SIDEBAR_WIDTH, FULL_BORDER,
-            ComputerBorderRenderer.TEX_SIZE, ComputerBorderRenderer.TEX_SIZE
-        );
-
-        Screen.blit(transform,
-            x, y + FULL_BORDER, AbstractComputerMenu.SIDEBAR_WIDTH, HEIGHT - FULL_BORDER * 2,
-            0, 107, AbstractComputerMenu.SIDEBAR_WIDTH, 4,
-            ComputerBorderRenderer.TEX_SIZE, ComputerBorderRenderer.TEX_SIZE
-        );
-
-        Screen.blit(transform,
-            x, y + HEIGHT - FULL_BORDER, 0, 111, AbstractComputerMenu.SIDEBAR_WIDTH, FULL_BORDER,
-            ComputerBorderRenderer.TEX_SIZE, ComputerBorderRenderer.TEX_SIZE
-        );
-    }
-
-    private static void toggleComputer(BooleanSupplier isOn, InputHandler input) {
-        if (isOn.getAsBoolean()) {
-            input.shutdown();
-        } else {
-            input.turnOn();
-        }
-    }
-}

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

@@ -1,93 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui.widgets;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.ChatFormatting;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.client.gui.components.Tooltip;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-
-import javax.annotation.Nullable;
-import java.util.function.IntSupplier;
-import java.util.function.Supplier;
-
-/**
- * Version of {@link net.minecraft.client.gui.components.ImageButton} which allows changing some properties
- * dynamically.
- */
-public class DynamicImageButton extends Button {
-    private final ResourceLocation texture;
-    private final IntSupplier xTexStart;
-    private final int yTexStart;
-    private final int yDiffTex;
-    private final int textureWidth;
-    private final int textureHeight;
-    private final Supplier<HintedMessage> message;
-
-    public DynamicImageButton(
-        int x, int y, int width, int height, int xTexStart, int yTexStart, int yDiffTex,
-        ResourceLocation texture, int textureWidth, int textureHeight,
-        OnPress onPress, HintedMessage message
-    ) {
-        this(
-            x, y, width, height, () -> xTexStart, yTexStart, yDiffTex,
-            texture, textureWidth, textureHeight,
-            onPress, () -> message
-        );
-    }
-
-    public DynamicImageButton(
-        int x, int y, int width, int height, IntSupplier xTexStart, int yTexStart, int yDiffTex,
-        ResourceLocation texture, int textureWidth, int textureHeight,
-        OnPress onPress, Supplier<HintedMessage> message
-    ) {
-        super(x, y, width, height, Component.empty(), onPress, DEFAULT_NARRATION);
-        this.textureWidth = textureWidth;
-        this.textureHeight = textureHeight;
-        this.xTexStart = xTexStart;
-        this.yTexStart = yTexStart;
-        this.yDiffTex = yDiffTex;
-        this.texture = texture;
-        this.message = message;
-    }
-
-    @Override
-    public void renderButton(PoseStack stack, int mouseX, int mouseY, float partialTicks) {
-        RenderSystem.setShaderTexture(0, texture);
-        RenderSystem.disableDepthTest();
-
-        var yTex = yTexStart;
-        if (isHoveredOrFocused()) yTex += yDiffTex;
-
-        blit(stack, getX(), getY(), xTexStart.getAsInt(), yTex, width, height, textureWidth, textureHeight);
-        RenderSystem.enableDepthTest();
-    }
-
-    @Override
-    public Component getMessage() {
-        return message.get().message;
-    }
-
-    @Override
-    public void render(PoseStack stack, int mouseX, int mouseY, float partialTicks) {
-        setTooltip(message.get().tooltip());
-        super.render(stack, mouseX, mouseY, partialTicks);
-    }
-
-    public record HintedMessage(Component message, Tooltip tooltip) {
-        public HintedMessage(Component message, @Nullable Component hint) {
-            this(
-                message,
-                hint == null
-                    ? Tooltip.create(message)
-                    : Tooltip.create(Component.empty().append(message).append("\n").append(hint.copy().withStyle(ChatFormatting.GRAY)), hint)
-            );
-        }
-    }
-}

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

@@ -1,295 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.gui.widgets;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.Tesselator;
-import dan200.computercraft.client.render.RenderTypes;
-import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
-import dan200.computercraft.core.terminal.Terminal;
-import dan200.computercraft.shared.computer.core.InputHandler;
-import net.minecraft.SharedConstants;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.components.AbstractWidget;
-import net.minecraft.client.gui.narration.NarratedElementType;
-import net.minecraft.client.gui.narration.NarrationElementOutput;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.network.chat.Component;
-import org.lwjgl.glfw.GLFW;
-
-import java.util.BitSet;
-
-import static dan200.computercraft.client.render.ComputerBorderRenderer.MARGIN;
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_HEIGHT;
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_WIDTH;
-
-public class TerminalWidget extends AbstractWidget {
-    private static final Component DESCRIPTION = Component.translatable("gui.computercraft.terminal");
-
-    private static final float TERMINATE_TIME = 0.5f;
-
-    private final Terminal terminal;
-    private final InputHandler computer;
-
-    // The positions of the actual terminal
-    private final int innerX;
-    private final int innerY;
-    private final int innerWidth;
-    private final int innerHeight;
-
-    private float terminateTimer = -1;
-    private float rebootTimer = -1;
-    private float shutdownTimer = -1;
-
-    private int lastMouseButton = -1;
-    private int lastMouseX = -1;
-    private int lastMouseY = -1;
-
-    private final BitSet keysDown = new BitSet(256);
-
-    public TerminalWidget(Terminal terminal, InputHandler computer, int x, int y) {
-        super(x, y, terminal.getWidth() * FONT_WIDTH + MARGIN * 2, terminal.getHeight() * FONT_HEIGHT + MARGIN * 2, DESCRIPTION);
-
-        this.terminal = terminal;
-        this.computer = computer;
-
-        innerX = x + MARGIN;
-        innerY = y + MARGIN;
-        innerWidth = terminal.getWidth() * FONT_WIDTH;
-        innerHeight = terminal.getHeight() * FONT_HEIGHT;
-    }
-
-    @Override
-    public boolean charTyped(char ch, int modifiers) {
-        if (ch >= 32 && ch <= 126 || ch >= 160 && ch <= 255) {
-            // Queue the char event for any printable chars in byte range
-            computer.queueEvent("char", new Object[]{ Character.toString(ch) });
-        }
-
-        return true;
-    }
-
-    @Override
-    public boolean keyPressed(int key, int scancode, int modifiers) {
-        if (key == GLFW.GLFW_KEY_ESCAPE) return false;
-        if ((modifiers & GLFW.GLFW_MOD_CONTROL) != 0) {
-            switch (key) {
-                case GLFW.GLFW_KEY_T -> {
-                    if (terminateTimer < 0) terminateTimer = 0;
-                    return true;
-                }
-                case GLFW.GLFW_KEY_S -> {
-                    if (shutdownTimer < 0) shutdownTimer = 0;
-                    return true;
-                }
-                case GLFW.GLFW_KEY_R -> {
-                    if (rebootTimer < 0) rebootTimer = 0;
-                    return true;
-                }
-                case GLFW.GLFW_KEY_V -> {
-                    // Ctrl+V for paste
-                    var clipboard = Minecraft.getInstance().keyboardHandler.getClipboard();
-                    if (clipboard != null) {
-                        // Clip to the first occurrence of \r or \n
-                        var newLineIndex1 = clipboard.indexOf("\r");
-                        var newLineIndex2 = clipboard.indexOf("\n");
-                        if (newLineIndex1 >= 0 && newLineIndex2 >= 0) {
-                            clipboard = clipboard.substring(0, Math.min(newLineIndex1, newLineIndex2));
-                        } else if (newLineIndex1 >= 0) {
-                            clipboard = clipboard.substring(0, newLineIndex1);
-                        } else if (newLineIndex2 >= 0) {
-                            clipboard = clipboard.substring(0, newLineIndex2);
-                        }
-
-                        // Filter the string
-                        clipboard = SharedConstants.filterText(clipboard);
-                        if (!clipboard.isEmpty()) {
-                            // Clip to 512 characters and queue the event
-                            if (clipboard.length() > 512) clipboard = clipboard.substring(0, 512);
-                            computer.queueEvent("paste", new Object[]{ clipboard });
-                        }
-
-                        return true;
-                    }
-                }
-            }
-        }
-
-        if (key >= 0 && terminateTimer < 0 && rebootTimer < 0 && shutdownTimer < 0) {
-            // Queue the "key" event and add to the down set
-            var repeat = keysDown.get(key);
-            keysDown.set(key);
-            computer.keyDown(key, repeat);
-        }
-
-        return true;
-    }
-
-    @Override
-    public boolean keyReleased(int key, int scancode, int modifiers) {
-        // Queue the "key_up" event and remove from the down set
-        if (key >= 0 && keysDown.get(key)) {
-            keysDown.set(key, false);
-            computer.keyUp(key);
-        }
-
-        switch (key) {
-            case GLFW.GLFW_KEY_T -> terminateTimer = -1;
-            case GLFW.GLFW_KEY_R -> rebootTimer = -1;
-            case GLFW.GLFW_KEY_S -> shutdownTimer = -1;
-            case GLFW.GLFW_KEY_LEFT_CONTROL, GLFW.GLFW_KEY_RIGHT_CONTROL ->
-                terminateTimer = rebootTimer = shutdownTimer = -1;
-        }
-
-        return true;
-    }
-
-    @Override
-    public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (!inTermRegion(mouseX, mouseY)) return false;
-        if (!hasMouseSupport() || button < 0 || button > 2) return false;
-
-        var charX = (int) ((mouseX - innerX) / FONT_WIDTH);
-        var charY = (int) ((mouseY - innerY) / FONT_HEIGHT);
-        charX = Math.min(Math.max(charX, 0), terminal.getWidth() - 1);
-        charY = Math.min(Math.max(charY, 0), terminal.getHeight() - 1);
-
-        computer.mouseClick(button + 1, charX + 1, charY + 1);
-
-        lastMouseButton = button;
-        lastMouseX = charX;
-        lastMouseY = charY;
-
-        return true;
-    }
-
-    @Override
-    public boolean mouseReleased(double mouseX, double mouseY, int button) {
-        if (!inTermRegion(mouseX, mouseY)) return false;
-        if (!hasMouseSupport() || button < 0 || button > 2) return false;
-
-        var charX = (int) ((mouseX - innerX) / FONT_WIDTH);
-        var charY = (int) ((mouseY - innerY) / FONT_HEIGHT);
-        charX = Math.min(Math.max(charX, 0), terminal.getWidth() - 1);
-        charY = Math.min(Math.max(charY, 0), terminal.getHeight() - 1);
-
-        if (lastMouseButton == button) {
-            computer.mouseUp(lastMouseButton + 1, charX + 1, charY + 1);
-            lastMouseButton = -1;
-        }
-
-        lastMouseX = charX;
-        lastMouseY = charY;
-
-        return true;
-    }
-
-    @Override
-    public boolean mouseDragged(double mouseX, double mouseY, int button, double v2, double v3) {
-        if (!inTermRegion(mouseX, mouseY)) return false;
-        if (!hasMouseSupport() || button < 0 || button > 2) return false;
-
-        var charX = (int) ((mouseX - innerX) / FONT_WIDTH);
-        var charY = (int) ((mouseY - innerY) / FONT_HEIGHT);
-        charX = Math.min(Math.max(charX, 0), terminal.getWidth() - 1);
-        charY = Math.min(Math.max(charY, 0), terminal.getHeight() - 1);
-
-        if (button == lastMouseButton && (charX != lastMouseX || charY != lastMouseY)) {
-            computer.mouseDrag(button + 1, charX + 1, charY + 1);
-            lastMouseX = charX;
-            lastMouseY = charY;
-        }
-
-        return true;
-    }
-
-    @Override
-    public boolean mouseScrolled(double mouseX, double mouseY, double delta) {
-        if (!inTermRegion(mouseX, mouseY)) return false;
-        if (!hasMouseSupport() || delta == 0) return false;
-
-        var charX = (int) ((mouseX - innerX) / FONT_WIDTH);
-        var charY = (int) ((mouseY - innerY) / FONT_HEIGHT);
-        charX = Math.min(Math.max(charX, 0), terminal.getWidth() - 1);
-        charY = Math.min(Math.max(charY, 0), terminal.getHeight() - 1);
-
-        computer.mouseScroll(delta < 0 ? 1 : -1, charX + 1, charY + 1);
-
-        lastMouseX = charX;
-        lastMouseY = charY;
-
-        return true;
-    }
-
-    private boolean inTermRegion(double mouseX, double mouseY) {
-        return active && visible && mouseX >= innerX && mouseY >= innerY && mouseX < innerX + innerWidth && mouseY < innerY + innerHeight;
-    }
-
-    private boolean hasMouseSupport() {
-        return terminal.isColour();
-    }
-
-    public void update() {
-        if (terminateTimer >= 0 && terminateTimer < TERMINATE_TIME && (terminateTimer += 0.05f) > TERMINATE_TIME) {
-            computer.queueEvent("terminate");
-        }
-
-        if (shutdownTimer >= 0 && shutdownTimer < TERMINATE_TIME && (shutdownTimer += 0.05f) > TERMINATE_TIME) {
-            computer.shutdown();
-        }
-
-        if (rebootTimer >= 0 && rebootTimer < TERMINATE_TIME && (rebootTimer += 0.05f) > TERMINATE_TIME) {
-            computer.reboot();
-        }
-    }
-
-    @Override
-    public void onFocusedChanged(boolean focused) {
-        if (!focused) {
-            // When blurring, we should make all keys go up
-            for (var key = 0; key < keysDown.size(); key++) {
-                if (keysDown.get(key)) computer.keyUp(key);
-            }
-            keysDown.clear();
-
-            // When blurring, we should make the last mouse button go up
-            if (lastMouseButton > 0) {
-                computer.mouseUp(lastMouseButton + 1, lastMouseX + 1, lastMouseY + 1);
-                lastMouseButton = -1;
-            }
-
-            shutdownTimer = terminateTimer = rebootTimer = -1;
-        }
-    }
-
-    @Override
-    public void render(PoseStack transform, int mouseX, int mouseY, float partialTicks) {
-        if (!visible) return;
-
-        var bufferSource = MultiBufferSource.immediate(Tesselator.getInstance().getBuilder());
-        var emitter = FixedWidthFontRenderer.toVertexConsumer(transform, bufferSource.getBuffer(RenderTypes.TERMINAL));
-
-        FixedWidthFontRenderer.drawTerminal(
-            emitter,
-            (float) innerX, (float) innerY, terminal, (float) MARGIN, (float) MARGIN, (float) MARGIN, (float) MARGIN
-        );
-
-        bufferSource.endBatch();
-    }
-
-    @Override
-    protected void updateWidgetNarration(NarrationElementOutput output) {
-        output.add(NarratedElementType.TITLE, getMessage());
-    }
-
-    public static int getWidth(int termWidth) {
-        return termWidth * FONT_WIDTH + MARGIN * 2;
-    }
-
-    public static int getHeight(int termHeight) {
-        return termHeight * FONT_HEIGHT + MARGIN * 2;
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/integration/ShaderMod.java

@@ -1,67 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.integration;
-
-import dan200.computercraft.client.render.RenderTypes;
-import dan200.computercraft.client.render.text.DirectFixedWidthFontRenderer;
-import dan200.computercraft.client.render.vbo.DirectVertexBuffer;
-
-import java.nio.ByteBuffer;
-import java.util.Optional;
-import java.util.ServiceLoader;
-import java.util.function.IntFunction;
-
-/**
- * Find the currently loaded shader mod (if present) and provides utilities for interacting with it.
- */
-public class ShaderMod {
-    public static ShaderMod get() {
-        return Storage.INSTANCE;
-    }
-
-    /**
-     * Determine if shaders may be used in the current session.
-     *
-     * @return Whether a shader mod is loaded.
-     */
-    public boolean isShaderMod() {
-        return Optifine.isLoaded();
-    }
-
-    /**
-     * Check whether we're currently rendering shadows. Rendering may fall back to a faster but less detailed pass.
-     *
-     * @return Whether we're rendering shadows.
-     */
-    public boolean isRenderingShadowPass() {
-        return false;
-    }
-
-    /**
-     * Get an appropriate quad emitter for use with {@link DirectVertexBuffer} and {@link DirectFixedWidthFontRenderer} .
-     *
-     * @param vertexCount The number of vertices.
-     * @param makeBuffer  A function to allocate a temporary buffer.
-     * @return The quad emitter.
-     */
-    public DirectFixedWidthFontRenderer.QuadEmitter getQuadEmitter(int vertexCount, IntFunction<ByteBuffer> makeBuffer) {
-        return new DirectFixedWidthFontRenderer.ByteBufferEmitter(
-            makeBuffer.apply(RenderTypes.TERMINAL.format().getVertexSize() * vertexCount * 4)
-        );
-    }
-
-    public interface Provider {
-        Optional<ShaderMod> get();
-    }
-
-    private static class Storage {
-        static final ShaderMod INSTANCE = ServiceLoader.load(Provider.class)
-            .stream()
-            .flatMap(x -> x.get().get().stream())
-            .findFirst()
-            .orElseGet(ShaderMod::new);
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/model/turtle/TurtleModelParts.java

@@ -1,119 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.model.turtle;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.math.Transformation;
-import dan200.computercraft.api.client.TransformedModel;
-import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.client.platform.ClientPlatformHelper;
-import dan200.computercraft.client.render.TurtleBlockEntityRenderer;
-import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
-import dan200.computercraft.shared.turtle.items.TurtleItem;
-import dan200.computercraft.shared.util.Holiday;
-import dan200.computercraft.shared.util.HolidayUtil;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-
-/**
- * Combines several individual models together to form a turtle.
- */
-public final class TurtleModelParts {
-    private static final Transformation identity, flip;
-
-    static {
-        var stack = new PoseStack();
-        stack.translate(0.5f, 0.5f, 0.5f);
-        stack.scale(1, -1, 1);
-        stack.translate(-0.5f, -0.5f, -0.5f);
-
-        identity = Transformation.identity();
-        flip = new Transformation(stack.last().pose());
-    }
-
-    public record Combination(
-        boolean colour,
-        @Nullable ITurtleUpgrade leftUpgrade,
-        @Nullable ITurtleUpgrade rightUpgrade,
-        @Nullable ResourceLocation overlay,
-        boolean christmas,
-        boolean flip
-    ) {
-    }
-
-    private final BakedModel familyModel;
-    private final BakedModel colourModel;
-    private final Function<TransformedModel, BakedModel> transformer;
-
-    /**
-     * A cache of {@link TransformedModel} to the transformed {@link BakedModel}. This helps us pool the transformed
-     * instances, reducing memory usage and hopefully ensuring their caches are hit more often!
-     */
-    private final Map<TransformedModel, BakedModel> transformCache = new HashMap<>();
-
-    public TurtleModelParts(BakedModel familyModel, BakedModel colourModel, ModelTransformer transformer) {
-        this.familyModel = familyModel;
-        this.colourModel = colourModel;
-        this.transformer = x -> transformer.transform(x.getModel(), x.getMatrix());
-    }
-
-    public Combination getCombination(ItemStack stack) {
-        var turtle = (TurtleItem) stack.getItem();
-
-        var colour = turtle.getColour(stack);
-        var leftUpgrade = turtle.getUpgrade(stack, TurtleSide.LEFT);
-        var rightUpgrade = turtle.getUpgrade(stack, TurtleSide.RIGHT);
-        var overlay = turtle.getOverlay(stack);
-        var christmas = HolidayUtil.getCurrentHoliday() == Holiday.CHRISTMAS;
-        var label = turtle.getLabel(stack);
-        var flip = label != null && (label.equals("Dinnerbone") || label.equals("Grumm"));
-
-        return new Combination(colour != -1, leftUpgrade, rightUpgrade, overlay, christmas, flip);
-    }
-
-    public List<BakedModel> buildModel(Combination combo) {
-        var mc = Minecraft.getInstance();
-        var modelManager = mc.getItemRenderer().getItemModelShaper().getModelManager();
-
-        var transformation = combo.flip ? flip : identity;
-        var parts = new ArrayList<BakedModel>(4);
-        parts.add(transform(combo.colour() ? colourModel : familyModel, transformation));
-
-        var overlayModelLocation = TurtleBlockEntityRenderer.getTurtleOverlayModel(combo.overlay(), combo.christmas());
-        if (overlayModelLocation != null) {
-            parts.add(transform(ClientPlatformHelper.get().getModel(modelManager, overlayModelLocation), transformation));
-        }
-        if (combo.leftUpgrade() != null) {
-            var model = TurtleUpgradeModellers.getModel(combo.leftUpgrade(), null, TurtleSide.LEFT);
-            parts.add(transform(model.getModel(), transformation.compose(model.getMatrix())));
-        }
-        if (combo.rightUpgrade() != null) {
-            var model = TurtleUpgradeModellers.getModel(combo.rightUpgrade(), null, TurtleSide.RIGHT);
-            parts.add(transform(model.getModel(), transformation.compose(model.getMatrix())));
-        }
-
-        return parts;
-    }
-
-    public BakedModel transform(BakedModel model, Transformation transformation) {
-        if (transformation.equals(Transformation.identity())) return model;
-        return transformCache.computeIfAbsent(new TransformedModel(model, transformation), transformer);
-    }
-
-    public interface ModelTransformer {
-        BakedModel transform(BakedModel model, Transformation transformation);
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/platform/AbstractClientNetworkContext.java

@@ -1,119 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.platform;
-
-import dan200.computercraft.client.ClientTableFormatter;
-import dan200.computercraft.client.gui.AbstractComputerScreen;
-import dan200.computercraft.client.gui.OptionScreen;
-import dan200.computercraft.client.pocket.ClientPocketComputers;
-import dan200.computercraft.client.sound.SpeakerManager;
-import dan200.computercraft.shared.command.text.TableBuilder;
-import dan200.computercraft.shared.computer.core.ComputerState;
-import dan200.computercraft.shared.computer.menu.ComputerMenu;
-import dan200.computercraft.shared.computer.terminal.TerminalState;
-import dan200.computercraft.shared.computer.upload.UploadResult;
-import dan200.computercraft.shared.network.client.ClientNetworkContext;
-import dan200.computercraft.shared.peripheral.monitor.MonitorBlockEntity;
-import dan200.computercraft.shared.peripheral.speaker.SpeakerPosition;
-import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
-import net.minecraft.core.BlockPos;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.level.Level;
-
-import javax.annotation.Nullable;
-import java.util.UUID;
-
-/**
- * The base implementation of {@link ClientNetworkContext}.
- * <p>
- * This should be extended by mod loader specific modules with the remaining abstract methods.
- */
-public abstract class AbstractClientNetworkContext implements ClientNetworkContext {
-    @Override
-    public final void handleChatTable(TableBuilder table) {
-        ClientTableFormatter.INSTANCE.display(table);
-    }
-
-    @Override
-    public final void handleComputerTerminal(int containerId, TerminalState terminal) {
-        Player player = Minecraft.getInstance().player;
-        if (player != null && player.containerMenu.containerId == containerId && player.containerMenu instanceof ComputerMenu menu) {
-            menu.updateTerminal(terminal);
-        }
-    }
-
-    @Override
-    public final void handleMonitorData(BlockPos pos, TerminalState terminal) {
-        var player = Minecraft.getInstance().player;
-        if (player == null) return;
-
-        var te = player.level.getBlockEntity(pos);
-        if (!(te instanceof MonitorBlockEntity monitor)) return;
-
-        monitor.read(terminal);
-    }
-
-    @Override
-    public final void handlePocketComputerData(int instanceId, ComputerState state, int lightState, TerminalState terminal) {
-        var computer = ClientPocketComputers.get(instanceId, terminal.colour);
-        computer.setState(state, lightState);
-        if (terminal.hasTerminal()) computer.setTerminal(terminal);
-    }
-
-    @Override
-    public final void handlePocketComputerDeleted(int instanceId) {
-        ClientPocketComputers.remove(instanceId);
-    }
-
-    @Override
-    public final void handleSpeakerAudio(UUID source, SpeakerPosition.Message position, float volume) {
-        SpeakerManager.getSound(source).playAudio(reifyPosition(position), volume);
-    }
-
-    @Override
-    public final void handleSpeakerAudioPush(UUID source, ByteBuf buffer) {
-        SpeakerManager.getSound(source).pushAudio(buffer);
-    }
-
-    @Override
-    public final void handleSpeakerMove(UUID source, SpeakerPosition.Message position) {
-        SpeakerManager.moveSound(source, reifyPosition(position));
-    }
-
-    @Override
-    public final void handleSpeakerPlay(UUID source, SpeakerPosition.Message position, ResourceLocation sound, float volume, float pitch) {
-        SpeakerManager.getSound(source).playSound(reifyPosition(position), sound, volume, pitch);
-    }
-
-    @Override
-    public final void handleSpeakerStop(UUID source) {
-        SpeakerManager.stopSound(source);
-    }
-
-    @Override
-    public final void handleUploadResult(int containerId, UploadResult result, @Nullable Component errorMessage) {
-        var minecraft = Minecraft.getInstance();
-
-        var screen = OptionScreen.unwrap(minecraft.screen);
-        if (screen instanceof AbstractComputerScreen<?> && ((AbstractComputerScreen<?>) screen).getMenu().containerId == containerId) {
-            ((AbstractComputerScreen<?>) screen).uploadResult(result, errorMessage);
-        }
-    }
-
-    private static SpeakerPosition reifyPosition(SpeakerPosition.Message pos) {
-        var minecraft = Minecraft.getInstance();
-        Level level = minecraft.level;
-        if (level != null && !level.dimension().location().equals(pos.level())) level = null;
-
-        return new SpeakerPosition(
-            level, pos.position(),
-            level != null && pos.entity().isPresent() ? level.getEntity(pos.entity().getAsInt()) : null
-        );
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/platform/ClientPlatformHelper.java

@@ -1,22 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.platform;
-
-import dan200.computercraft.shared.network.NetworkMessage;
-import dan200.computercraft.shared.network.server.ServerNetworkContext;
-
-public interface ClientPlatformHelper extends dan200.computercraft.impl.client.ClientPlatformHelper {
-    static ClientPlatformHelper get() {
-        return (ClientPlatformHelper) dan200.computercraft.impl.client.ClientPlatformHelper.get();
-    }
-
-    /**
-     * Send a network message to the server.
-     *
-     * @param message The message to send.
-     */
-    void sendToServer(NetworkMessage<ServerNetworkContext> message);
-}

projects/common/src/client/java/dan200/computercraft/client/render/CableHighlightRenderer.java

@@ -1,80 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.peripheral.modem.wired.CableBlock;
-import dan200.computercraft.shared.peripheral.modem.wired.CableShapes;
-import dan200.computercraft.shared.util.WorldUtil;
-import net.minecraft.client.Camera;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.util.Mth;
-import net.minecraft.world.phys.BlockHitResult;
-
-public final class CableHighlightRenderer {
-    private CableHighlightRenderer() {
-    }
-
-    /**
-     * Draw an outline for a specific part of a cable "Multipart".
-     *
-     * @param transform    The current transformation matrix.
-     * @param bufferSource The buffer to draw to.
-     * @param camera       The current camera.
-     * @param hit          The block hit result for the current player.
-     * @return If we rendered a custom outline.
-     * @see net.minecraft.client.renderer.LevelRenderer#renderHitOutline
-     */
-    public static boolean drawHighlight(PoseStack transform, MultiBufferSource bufferSource, Camera camera, BlockHitResult hit) {
-        var pos = hit.getBlockPos();
-        var world = camera.getEntity().getCommandSenderWorld();
-
-        var state = world.getBlockState(pos);
-
-        // We only care about instances with both cable and modem.
-        if (state.getBlock() != ModRegistry.Blocks.CABLE.get() || state.getValue(CableBlock.MODEM).getFacing() == null || !state.getValue(CableBlock.CABLE)) {
-            return false;
-        }
-
-        var shape = WorldUtil.isVecInside(CableShapes.getModemShape(state), hit.getLocation().subtract(pos.getX(), pos.getY(), pos.getZ()))
-            ? CableShapes.getModemShape(state)
-            : CableShapes.getCableShape(state);
-
-        var cameraPos = camera.getPosition();
-        var xOffset = pos.getX() - cameraPos.x();
-        var yOffset = pos.getY() - cameraPos.y();
-        var zOffset = pos.getZ() - cameraPos.z();
-
-        var buffer = bufferSource.getBuffer(RenderType.lines());
-        var matrix4f = transform.last().pose();
-        var normal = transform.last().normal();
-        // TODO: Can we just accesstransformer out LevelRenderer.renderShape?
-        shape.forAllEdges((x1, y1, z1, x2, y2, z2) -> {
-            var xDelta = (float) (x2 - x1);
-            var yDelta = (float) (y2 - y1);
-            var zDelta = (float) (z2 - z1);
-            var len = Mth.sqrt(xDelta * xDelta + yDelta * yDelta + zDelta * zDelta);
-            xDelta = xDelta / len;
-            yDelta = yDelta / len;
-            zDelta = zDelta / len;
-
-            buffer
-                .vertex(matrix4f, (float) (x1 + xOffset), (float) (y1 + yOffset), (float) (z1 + zOffset))
-                .color(0, 0, 0, 0.4f)
-                .normal(normal, xDelta, yDelta, zDelta)
-                .endVertex();
-            buffer
-                .vertex(matrix4f, (float) (x2 + xOffset), (float) (y2 + yOffset), (float) (z2 + zOffset))
-                .color(0, 0, 0, 0.4f)
-                .normal(normal, xDelta, yDelta, zDelta)
-                .endVertex();
-        });
-
-        return true;
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/ComputerBorderRenderer.java

@@ -1,129 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render;
-
-import com.mojang.blaze3d.vertex.Tesselator;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.shared.computer.core.ComputerFamily;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.resources.ResourceLocation;
-import org.joml.Matrix4f;
-
-public class ComputerBorderRenderer {
-    public static final ResourceLocation BACKGROUND_NORMAL = new ResourceLocation(ComputerCraftAPI.MOD_ID, "textures/gui/corners_normal.png");
-    public static final ResourceLocation BACKGROUND_ADVANCED = new ResourceLocation(ComputerCraftAPI.MOD_ID, "textures/gui/corners_advanced.png");
-    public static final ResourceLocation BACKGROUND_COMMAND = new ResourceLocation(ComputerCraftAPI.MOD_ID, "textures/gui/corners_command.png");
-    public static final ResourceLocation BACKGROUND_COLOUR = new ResourceLocation(ComputerCraftAPI.MOD_ID, "textures/gui/corners_colour.png");
-
-    /**
-     * The margin between the terminal and its border.
-     */
-    public static final int MARGIN = 2;
-
-    /**
-     * The width of the terminal border.
-     */
-    public static final int BORDER = 12;
-
-    private static final int CORNER_TOP_Y = 28;
-    private static final int CORNER_BOTTOM_Y = CORNER_TOP_Y + BORDER;
-    private static final int CORNER_LEFT_X = BORDER;
-    private static final int CORNER_RIGHT_X = CORNER_LEFT_X + BORDER;
-    private static final int BORDER_RIGHT_X = 36;
-    private static final int LIGHT_BORDER_Y = 56;
-    private static final int LIGHT_CORNER_Y = 80;
-
-    public static final int LIGHT_HEIGHT = 8;
-
-    public static final int TEX_SIZE = 256;
-    private static final float TEX_SCALE = 1 / (float) TEX_SIZE;
-
-    private final Matrix4f transform;
-    private final VertexConsumer builder;
-    private final int light;
-    private final int z;
-    private final float r, g, b;
-
-    public ComputerBorderRenderer(Matrix4f transform, VertexConsumer builder, int z, int light, float r, float g, float b) {
-        this.transform = transform;
-        this.builder = builder;
-        this.z = z;
-        this.light = light;
-        this.r = r;
-        this.g = g;
-        this.b = b;
-    }
-
-    public static ResourceLocation getTexture(ComputerFamily family) {
-        return switch (family) {
-            case NORMAL -> BACKGROUND_NORMAL;
-            case ADVANCED -> BACKGROUND_ADVANCED;
-            case COMMAND -> BACKGROUND_COMMAND;
-        };
-    }
-
-    public static RenderType getRenderType(ResourceLocation location) {
-        // See note in RenderTypes about why we use text rather than anything intuitive.
-        return RenderType.text(location);
-    }
-
-    public static void render(Matrix4f transform, ResourceLocation location, int x, int y, int z, int light, int width, int height) {
-        var source = MultiBufferSource.immediate(Tesselator.getInstance().getBuilder());
-        render(transform, source.getBuffer(getRenderType(location)), x, y, z, light, width, height, false, 1, 1, 1);
-        source.endBatch();
-    }
-
-    public static void render(Matrix4f transform, VertexConsumer buffer, int x, int y, int z, int light, int width, int height, boolean withLight, float r, float g, float b) {
-        new ComputerBorderRenderer(transform, buffer, z, light, r, g, b).doRender(x, y, width, height, withLight);
-    }
-
-    public void doRender(int x, int y, int width, int height, boolean withLight) {
-        var endX = x + width;
-        var endY = y + height;
-
-        // Vertical bars
-        renderLine(x - BORDER, y, 0, CORNER_TOP_Y, BORDER, endY - y);
-        renderLine(endX, y, BORDER_RIGHT_X, CORNER_TOP_Y, BORDER, endY - y);
-
-        // Top bar
-        renderLine(x, y - BORDER, 0, 0, endX - x, BORDER);
-        renderCorner(x - BORDER, y - BORDER, CORNER_LEFT_X, CORNER_TOP_Y);
-        renderCorner(endX, y - BORDER, CORNER_RIGHT_X, CORNER_TOP_Y);
-
-        // Bottom bar. We allow for drawing a stretched version, which allows for additional elements (such as the
-        // pocket computer's lights).
-        if (withLight) {
-            renderTexture(x, endY, 0, LIGHT_BORDER_Y, endX - x, BORDER + LIGHT_HEIGHT, BORDER, BORDER + LIGHT_HEIGHT);
-            renderTexture(x - BORDER, endY, CORNER_LEFT_X, LIGHT_CORNER_Y, BORDER, BORDER + LIGHT_HEIGHT);
-            renderTexture(endX, endY, CORNER_RIGHT_X, LIGHT_CORNER_Y, BORDER, BORDER + LIGHT_HEIGHT);
-        } else {
-            renderLine(x, endY, 0, BORDER, endX - x, BORDER);
-            renderCorner(x - BORDER, endY, CORNER_LEFT_X, CORNER_BOTTOM_Y);
-            renderCorner(endX, endY, CORNER_RIGHT_X, CORNER_BOTTOM_Y);
-        }
-    }
-
-    private void renderCorner(int x, int y, int u, int v) {
-        renderTexture(x, y, u, v, BORDER, BORDER, BORDER, BORDER);
-    }
-
-    private void renderLine(int x, int y, int u, int v, int width, int height) {
-        renderTexture(x, y, u, v, width, height, BORDER, BORDER);
-    }
-
-    private void renderTexture(int x, int y, int u, int v, int width, int height) {
-        renderTexture(x, y, u, v, width, height, width, height);
-    }
-
-    private void renderTexture(int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight) {
-        builder.vertex(transform, x, y + height, z).color(r, g, b, 1.0f).uv(u * TEX_SCALE, (v + textureHeight) * TEX_SCALE).uv2(light).endVertex();
-        builder.vertex(transform, x + width, y + height, z).color(r, g, b, 1.0f).uv((u + textureWidth) * TEX_SCALE, (v + textureHeight) * TEX_SCALE).uv2(light).endVertex();
-        builder.vertex(transform, x + width, y, z).color(r, g, b, 1.0f).uv((u + textureWidth) * TEX_SCALE, v * TEX_SCALE).uv2(light).endVertex();
-        builder.vertex(transform, x, y, z).color(r, g, b, 1.0f).uv(u * TEX_SCALE, v * TEX_SCALE).uv2(light).endVertex();
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/PocketItemRenderer.java

@@ -1,98 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.math.Axis;
-import dan200.computercraft.client.pocket.ClientPocketComputers;
-import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
-import dan200.computercraft.core.util.Colour;
-import dan200.computercraft.shared.computer.core.ComputerFamily;
-import dan200.computercraft.shared.pocket.items.PocketComputerItem;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.world.item.ItemStack;
-import org.joml.Matrix4f;
-
-import static dan200.computercraft.client.render.ComputerBorderRenderer.*;
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_HEIGHT;
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_WIDTH;
-
-/**
- * Emulates map rendering for pocket computers.
- */
-public final class PocketItemRenderer extends ItemMapLikeRenderer {
-    public static final PocketItemRenderer INSTANCE = new PocketItemRenderer();
-
-    private PocketItemRenderer() {
-    }
-
-    @Override
-    protected void renderItem(PoseStack transform, MultiBufferSource bufferSource, ItemStack stack, int light) {
-        var computer = ClientPocketComputers.get(stack);
-        var terminal = computer.getTerminal();
-
-        var termWidth = terminal.getWidth();
-        var termHeight = terminal.getHeight();
-
-        var width = termWidth * FONT_WIDTH + MARGIN * 2;
-        var height = termHeight * FONT_HEIGHT + MARGIN * 2;
-
-        // Setup various transformations. Note that these are partially adapted from the corresponding method
-        // in ItemRenderer
-        transform.pushPose();
-        transform.mulPose(Axis.YP.rotationDegrees(180f));
-        transform.mulPose(Axis.ZP.rotationDegrees(180f));
-        transform.scale(0.5f, 0.5f, 0.5f);
-
-        var scale = 0.75f / Math.max(width + BORDER * 2, height + BORDER * 2 + LIGHT_HEIGHT);
-        transform.scale(scale, scale, -1.0f);
-        transform.translate(-0.5 * width, -0.5 * height, 0);
-
-        // Render the main frame
-        var item = (PocketComputerItem) stack.getItem();
-        var family = item.getFamily();
-        var frameColour = item.getColour(stack);
-
-        var matrix = transform.last().pose();
-        renderFrame(matrix, bufferSource, family, frameColour, light, width, height);
-
-        // Render the light
-        var lightColour = ClientPocketComputers.get(stack).getLightState();
-        if (lightColour == -1) lightColour = Colour.BLACK.getHex();
-        renderLight(transform, bufferSource, lightColour, width, height);
-
-        FixedWidthFontRenderer.drawTerminal(
-            FixedWidthFontRenderer.toVertexConsumer(transform, bufferSource.getBuffer(RenderTypes.TERMINAL)),
-            MARGIN, MARGIN, terminal, MARGIN, MARGIN, MARGIN, MARGIN
-        );
-
-        transform.popPose();
-    }
-
-    private static void renderFrame(Matrix4f transform, MultiBufferSource render, ComputerFamily family, int colour, int light, int width, int height) {
-        var texture = colour != -1 ? ComputerBorderRenderer.BACKGROUND_COLOUR : ComputerBorderRenderer.getTexture(family);
-
-        var r = ((colour >>> 16) & 0xFF) / 255.0f;
-        var g = ((colour >>> 8) & 0xFF) / 255.0f;
-        var b = (colour & 0xFF) / 255.0f;
-
-        ComputerBorderRenderer.render(transform, render.getBuffer(ComputerBorderRenderer.getRenderType(texture)), 0, 0, 0, light, width, height, true, r, g, b);
-    }
-
-    private static void renderLight(PoseStack transform, MultiBufferSource render, int colour, int width, int height) {
-        var r = (byte) ((colour >>> 16) & 0xFF);
-        var g = (byte) ((colour >>> 8) & 0xFF);
-        var b = (byte) (colour & 0xFF);
-        var c = new byte[]{ r, g, b, (byte) 255 };
-
-        var buffer = render.getBuffer(RenderTypes.TERMINAL);
-        FixedWidthFontRenderer.drawQuad(
-            FixedWidthFontRenderer.toVertexConsumer(transform, buffer),
-            width - LIGHT_HEIGHT * 2, height + BORDER / 2.0f, 0.001f, LIGHT_HEIGHT * 2, LIGHT_HEIGHT,
-            c, RenderTypes.FULL_BRIGHT_LIGHTMAP
-        );
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/PrintoutItemRenderer.java

@@ -1,84 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.math.Axis;
-import dan200.computercraft.shared.media.items.PrintoutItem;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.world.entity.EntityType;
-import net.minecraft.world.entity.decoration.ItemFrame;
-import net.minecraft.world.item.ItemStack;
-
-import static dan200.computercraft.client.render.PrintoutRenderer.*;
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_HEIGHT;
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_WIDTH;
-import static dan200.computercraft.shared.media.items.PrintoutItem.LINES_PER_PAGE;
-import static dan200.computercraft.shared.media.items.PrintoutItem.LINE_MAX_LENGTH;
-
-/**
- * Emulates map and item-frame rendering for printouts.
- */
-public final class PrintoutItemRenderer extends ItemMapLikeRenderer {
-    public static final PrintoutItemRenderer INSTANCE = new PrintoutItemRenderer();
-
-    private PrintoutItemRenderer() {
-    }
-
-    @Override
-    protected void renderItem(PoseStack transform, MultiBufferSource render, ItemStack stack, int light) {
-        transform.mulPose(Axis.XP.rotationDegrees(180f));
-        transform.scale(0.42f, 0.42f, -0.42f);
-        transform.translate(-0.5f, -0.48f, 0.0f);
-
-        drawPrintout(transform, render, stack, light);
-    }
-
-    public static void onRenderInFrame(PoseStack transform, MultiBufferSource render, ItemFrame frame, ItemStack stack, int packedLight) {
-        if (!(stack.getItem() instanceof PrintoutItem)) return;
-
-        // Move a little bit forward to ensure we're not clipping with the frame
-        transform.translate(0.0f, 0.0f, -0.001f);
-        transform.mulPose(Axis.ZP.rotationDegrees(180f));
-        transform.scale(0.95f, 0.95f, -0.95f);
-        transform.translate(-0.5f, -0.5f, 0.0f);
-
-        var light = frame.getType() == EntityType.GLOW_ITEM_FRAME ? 0xf000d2 : packedLight; // See getLightVal.
-        drawPrintout(transform, render, stack, light);
-    }
-
-    private static void drawPrintout(PoseStack transform, MultiBufferSource render, ItemStack stack, int light) {
-        var pages = PrintoutItem.getPageCount(stack);
-        var book = ((PrintoutItem) stack.getItem()).getType() == PrintoutItem.Type.BOOK;
-
-        double width = LINE_MAX_LENGTH * FONT_WIDTH + X_TEXT_MARGIN * 2;
-        double height = LINES_PER_PAGE * FONT_HEIGHT + Y_TEXT_MARGIN * 2;
-
-        // Non-books will be left aligned
-        if (!book) width += offsetAt(pages - 1);
-
-        double visualWidth = width, visualHeight = height;
-
-        // Meanwhile books will be centred
-        if (book) {
-            visualWidth += 2 * COVER_SIZE + 2 * offsetAt(pages);
-            visualHeight += 2 * COVER_SIZE;
-        }
-
-        var max = Math.max(visualHeight, visualWidth);
-
-        // Scale the printout to fit correctly.
-        var scale = (float) (1.0 / max);
-        transform.scale(scale, scale, scale);
-        transform.translate((max - width) / 2.0, (max - height) / 2.0, 0.0);
-
-        drawBorder(transform, render, 0, 0, -0.01f, 0, pages, book, light);
-        drawText(
-            transform, render, X_TEXT_MARGIN, Y_TEXT_MARGIN, 0, light,
-            PrintoutItem.getText(stack), PrintoutItem.getColours(stack)
-        );
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/PrintoutRenderer.java

@@ -1,160 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
-import dan200.computercraft.core.terminal.Palette;
-import dan200.computercraft.core.terminal.TextBuffer;
-import net.minecraft.client.renderer.MultiBufferSource;
-import org.joml.Matrix4f;
-
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_HEIGHT;
-import static dan200.computercraft.shared.media.items.PrintoutItem.LINES_PER_PAGE;
-
-public final class PrintoutRenderer {
-    private static final float BG_SIZE = 256.0f;
-
-    /**
-     * Width of a page.
-     */
-    public static final int X_SIZE = 172;
-
-    /**
-     * Height of a page.
-     */
-    public static final int Y_SIZE = 209;
-
-    /**
-     * Padding between the left and right of a page and the text.
-     */
-    public static final int X_TEXT_MARGIN = 13;
-
-    /**
-     * Padding between the top and bottom of a page and the text.
-     */
-    public static final int Y_TEXT_MARGIN = 11;
-
-    /**
-     * Width of the extra page texture.
-     */
-    private static final int X_FOLD_SIZE = 12;
-
-    /**
-     * Size of the leather cover.
-     */
-    public static final int COVER_SIZE = 12;
-
-    private static final int COVER_Y = Y_SIZE;
-    private static final int COVER_X = X_SIZE + 4 * X_FOLD_SIZE;
-
-    private PrintoutRenderer() {
-    }
-
-    public static void drawText(PoseStack transform, MultiBufferSource bufferSource, int x, int y, int start, int light, TextBuffer[] text, TextBuffer[] colours) {
-        var buffer = bufferSource.getBuffer(RenderTypes.PRINTOUT_TEXT);
-        var emitter = FixedWidthFontRenderer.toVertexConsumer(transform, buffer);
-        for (var line = 0; line < LINES_PER_PAGE && line < text.length; line++) {
-            FixedWidthFontRenderer.drawString(emitter,
-                x, y + line * FONT_HEIGHT, text[start + line], colours[start + line],
-                Palette.DEFAULT, light
-            );
-        }
-    }
-
-    public static void drawText(PoseStack transform, MultiBufferSource bufferSource, int x, int y, int start, int light, String[] text, String[] colours) {
-        var buffer = bufferSource.getBuffer(RenderTypes.PRINTOUT_TEXT);
-        var emitter = FixedWidthFontRenderer.toVertexConsumer(transform, buffer);
-        for (var line = 0; line < LINES_PER_PAGE && line < text.length; line++) {
-            FixedWidthFontRenderer.drawString(emitter,
-                x, y + line * FONT_HEIGHT,
-                new TextBuffer(text[start + line]), new TextBuffer(colours[start + line]),
-                Palette.DEFAULT, light
-            );
-        }
-    }
-
-    public static void drawBorder(PoseStack transform, MultiBufferSource bufferSource, float x, float y, float z, int page, int pages, boolean isBook, int light) {
-        var matrix = transform.last().pose();
-        var leftPages = page;
-        var rightPages = pages - page - 1;
-
-        var buffer = bufferSource.getBuffer(RenderTypes.PRINTOUT_BACKGROUND);
-
-        if (isBook) {
-            // Border
-            var offset = offsetAt(pages);
-            var left = x - 4 - offset;
-            var right = x + X_SIZE + offset - 4;
-
-            // Left and right border
-            drawTexture(matrix, buffer, left - 4, y - 8, z - 0.02f, COVER_X, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2, light);
-            drawTexture(matrix, buffer, right, y - 8, z - 0.02f, COVER_X + COVER_SIZE, 0, COVER_SIZE, Y_SIZE + COVER_SIZE * 2, light);
-
-            // Draw centre panel (just stretched texture, sorry).
-            drawTexture(matrix, buffer,
-                x - offset, y, z - 0.02f, X_SIZE + offset * 2, Y_SIZE,
-                COVER_X + COVER_SIZE / 2.0f, COVER_SIZE, COVER_SIZE, Y_SIZE,
-                light
-            );
-
-            var borderX = left;
-            while (borderX < right) {
-                double thisWidth = Math.min(right - borderX, X_SIZE);
-                drawTexture(matrix, buffer, borderX, y - 8, z - 0.02f, 0, COVER_Y, (float) thisWidth, COVER_SIZE, light);
-                drawTexture(matrix, buffer, borderX, y + Y_SIZE - 4, z - 0.02f, 0, COVER_Y + COVER_SIZE, (float) thisWidth, COVER_SIZE, light);
-                borderX = (float) (borderX + thisWidth);
-            }
-        }
-
-        // Current page background: Z-offset is interleaved between the "zeroth" left/right page and the first
-        // left/right page, so that the "bold" border can be drawn over the edge where appropriate.
-        drawTexture(matrix, buffer, x, y, z - 1e-3f * 0.5f, X_FOLD_SIZE * 2, 0, X_SIZE, Y_SIZE, light);
-
-        // Left pages
-        for (var n = 0; n <= leftPages; n++) {
-            drawTexture(matrix, buffer,
-                x - offsetAt(n), y, z - 1e-3f * n,
-                // Use the left "bold" fold for the outermost page
-                n == leftPages ? 0 : X_FOLD_SIZE, 0,
-                X_FOLD_SIZE, Y_SIZE, light
-            );
-        }
-
-        // Right pages
-        for (var n = 0; n <= rightPages; n++) {
-            drawTexture(matrix, buffer,
-                x + (X_SIZE - X_FOLD_SIZE) + offsetAt(n), y, z - 1e-3f * n,
-                // Two folds, then the main page. Use the right "bold" fold for the outermost page.
-                X_FOLD_SIZE * 2 + X_SIZE + (n == rightPages ? X_FOLD_SIZE : 0), 0,
-                X_FOLD_SIZE, Y_SIZE, light
-            );
-        }
-    }
-
-    private static void drawTexture(Matrix4f matrix, VertexConsumer buffer, float x, float y, float z, float u, float v, float width, float height, int light) {
-        vertex(buffer, matrix, x, y + height, z, u / BG_SIZE, (v + height) / BG_SIZE, light);
-        vertex(buffer, matrix, x + width, y + height, z, (u + width) / BG_SIZE, (v + height) / BG_SIZE, light);
-        vertex(buffer, matrix, x + width, y, z, (u + width) / BG_SIZE, v / BG_SIZE, light);
-        vertex(buffer, matrix, x, y, z, u / BG_SIZE, v / BG_SIZE, light);
-    }
-
-    private static void drawTexture(Matrix4f matrix, VertexConsumer buffer, float x, float y, float z, float width, float height, float u, float v, float tWidth, float tHeight, int light) {
-        vertex(buffer, matrix, x, y + height, z, u / BG_SIZE, (v + tHeight) / BG_SIZE, light);
-        vertex(buffer, matrix, x + width, y + height, z, (u + tWidth) / BG_SIZE, (v + tHeight) / BG_SIZE, light);
-        vertex(buffer, matrix, x + width, y, z, (u + tWidth) / BG_SIZE, v / BG_SIZE, light);
-        vertex(buffer, matrix, x, y, z, u / BG_SIZE, v / BG_SIZE, light);
-    }
-
-    private static void vertex(VertexConsumer buffer, Matrix4f matrix, float x, float y, float z, float u, float v, int light) {
-        buffer.vertex(matrix, x, y, z).color(255, 255, 255, 255).uv(u, v).uv2(light).endVertex();
-    }
-
-    public static float offsetAt(int page) {
-        return (float) (32 * (1 - Math.pow(1.2, -page)));
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/TurtleBlockEntityRenderer.java

@@ -1,188 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import com.mojang.math.Axis;
-import com.mojang.math.Transformation;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.client.platform.ClientPlatformHelper;
-import dan200.computercraft.client.turtle.TurtleUpgradeModellers;
-import dan200.computercraft.shared.computer.core.ComputerFamily;
-import dan200.computercraft.shared.turtle.blocks.TurtleBlockEntity;
-import dan200.computercraft.shared.util.DirectionUtil;
-import dan200.computercraft.shared.util.Holiday;
-import dan200.computercraft.shared.util.HolidayUtil;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.Font;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.Sheets;
-import net.minecraft.client.renderer.block.model.BakedQuad;
-import net.minecraft.client.renderer.blockentity.BlockEntityRenderDispatcher;
-import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
-import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraft.client.resources.model.ModelResourceLocation;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.util.RandomSource;
-import net.minecraft.world.phys.BlockHitResult;
-import net.minecraft.world.phys.HitResult;
-
-import javax.annotation.Nullable;
-import java.util.List;
-
-public class TurtleBlockEntityRenderer implements BlockEntityRenderer<TurtleBlockEntity> {
-    private static final ModelResourceLocation NORMAL_TURTLE_MODEL = new ModelResourceLocation(ComputerCraftAPI.MOD_ID, "turtle_normal", "inventory");
-    private static final ModelResourceLocation ADVANCED_TURTLE_MODEL = new ModelResourceLocation(ComputerCraftAPI.MOD_ID, "turtle_advanced", "inventory");
-    private static final ResourceLocation COLOUR_TURTLE_MODEL = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_colour");
-    private static final ResourceLocation ELF_OVERLAY_MODEL = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_elf_overlay");
-
-    private final RandomSource random = RandomSource.create(0);
-
-    private final BlockEntityRenderDispatcher renderer;
-    private final Font font;
-
-    public TurtleBlockEntityRenderer(BlockEntityRendererProvider.Context context) {
-        renderer = context.getBlockEntityRenderDispatcher();
-        font = context.getFont();
-    }
-
-    public static ResourceLocation getTurtleModel(ComputerFamily family, boolean coloured) {
-        return switch (family) {
-            default -> coloured ? COLOUR_TURTLE_MODEL : NORMAL_TURTLE_MODEL;
-            case ADVANCED -> coloured ? COLOUR_TURTLE_MODEL : ADVANCED_TURTLE_MODEL;
-        };
-    }
-
-    public static @Nullable ResourceLocation getTurtleOverlayModel(@Nullable ResourceLocation overlay, boolean christmas) {
-        if (overlay != null) return overlay;
-        if (christmas) return ELF_OVERLAY_MODEL;
-        return null;
-    }
-
-    @Override
-    public void render(TurtleBlockEntity turtle, float partialTicks, PoseStack transform, MultiBufferSource buffers, int lightmapCoord, int overlayLight) {
-        transform.pushPose();
-
-        // Translate the turtle first, so the label moves with it.
-        var offset = turtle.getRenderOffset(partialTicks);
-        transform.translate(offset.x, offset.y, offset.z);
-
-        // Render the label
-        var label = turtle.getLabel();
-        var hit = renderer.cameraHitResult;
-        if (label != null && hit.getType() == HitResult.Type.BLOCK && turtle.getBlockPos().equals(((BlockHitResult) hit).getBlockPos())) {
-            var mc = Minecraft.getInstance();
-            var font = this.font;
-
-            transform.pushPose();
-            transform.translate(0.5, 1.2, 0.5);
-            transform.mulPose(mc.getEntityRenderDispatcher().cameraOrientation());
-            transform.scale(-0.025f, -0.025f, 0.025f);
-
-            var matrix = transform.last().pose();
-            var opacity = (int) (mc.options.getBackgroundOpacity(0.25f) * 255) << 24;
-            var width = -font.width(label) / 2.0f;
-            font.drawInBatch(label, width, (float) 0, 0x20ffffff, false, matrix, buffers, true, opacity, lightmapCoord);
-            font.drawInBatch(label, width, (float) 0, 0xffffffff, false, matrix, buffers, false, 0, lightmapCoord);
-
-            transform.popPose();
-        }
-
-        // Then apply rotation and flip if needed.
-        transform.translate(0.5f, 0.5f, 0.5f);
-        var yaw = turtle.getRenderYaw(partialTicks);
-        transform.mulPose(Axis.YP.rotationDegrees(180.0f - yaw));
-        if (label != null && (label.equals("Dinnerbone") || label.equals("Grumm"))) {
-            transform.scale(1.0f, -1.0f, 1.0f);
-        }
-        transform.translate(-0.5f, -0.5f, -0.5f);
-
-        // Render the turtle
-        var colour = turtle.getColour();
-        var family = turtle.getFamily();
-        var overlay = turtle.getOverlay();
-
-        var buffer = buffers.getBuffer(Sheets.translucentCullBlockSheet());
-        renderModel(transform, buffer, lightmapCoord, overlayLight, getTurtleModel(family, colour != -1), colour == -1 ? null : new int[]{ colour });
-
-        // Render the overlay
-        var overlayModel = getTurtleOverlayModel(overlay, HolidayUtil.getCurrentHoliday() == Holiday.CHRISTMAS);
-        if (overlayModel != null) {
-            renderModel(transform, buffer, lightmapCoord, overlayLight, overlayModel, null);
-        }
-
-        // Render the upgrades
-        renderUpgrade(transform, buffer, lightmapCoord, overlayLight, turtle, TurtleSide.LEFT, partialTicks);
-        renderUpgrade(transform, buffer, lightmapCoord, overlayLight, turtle, TurtleSide.RIGHT, partialTicks);
-
-        transform.popPose();
-    }
-
-    private void renderUpgrade(PoseStack transform, VertexConsumer renderer, int lightmapCoord, int overlayLight, TurtleBlockEntity turtle, TurtleSide side, float f) {
-        var upgrade = turtle.getUpgrade(side);
-        if (upgrade == null) return;
-        transform.pushPose();
-
-        var toolAngle = turtle.getToolRenderAngle(side, f);
-        transform.translate(0.0f, 0.5f, 0.5f);
-        transform.mulPose(Axis.XN.rotationDegrees(toolAngle));
-        transform.translate(0.0f, -0.5f, -0.5f);
-
-        var model = TurtleUpgradeModellers.getModel(upgrade, turtle.getAccess(), side);
-        pushPoseFromTransformation(transform, model.getMatrix());
-        renderModel(transform, renderer, lightmapCoord, overlayLight, model.getModel(), null);
-        transform.popPose();
-
-        transform.popPose();
-    }
-
-    private void renderModel(PoseStack transform, VertexConsumer renderer, int lightmapCoord, int overlayLight, ResourceLocation modelLocation, @Nullable int[] tints) {
-        var modelManager = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getModelManager();
-        renderModel(transform, renderer, lightmapCoord, overlayLight, ClientPlatformHelper.get().getModel(modelManager, modelLocation), tints);
-    }
-
-    private void renderModel(PoseStack transform, VertexConsumer renderer, int lightmapCoord, int overlayLight, BakedModel model, @Nullable int[] tints) {
-        random.setSeed(0);
-        renderQuads(transform, renderer, lightmapCoord, overlayLight, model.getQuads(null, null, random), tints);
-        for (var facing : DirectionUtil.FACINGS) {
-            renderQuads(transform, renderer, lightmapCoord, overlayLight, model.getQuads(null, facing, random), tints);
-        }
-    }
-
-    private static void renderQuads(PoseStack transform, VertexConsumer buffer, int lightmapCoord, int overlayLight, List<BakedQuad> quads, @Nullable int[] tints) {
-        var matrix = transform.last();
-
-        for (var bakedquad : quads) {
-            var tint = -1;
-            if (tints != null && bakedquad.isTinted()) {
-                var idx = bakedquad.getTintIndex();
-                if (idx >= 0 && idx < tints.length) tint = tints[bakedquad.getTintIndex()];
-            }
-
-            var r = (float) (tint >> 16 & 255) / 255.0F;
-            var g = (float) (tint >> 8 & 255) / 255.0F;
-            var b = (float) (tint & 255) / 255.0F;
-            buffer.putBulkData(matrix, bakedquad, r, g, b, lightmapCoord, overlayLight);
-        }
-    }
-
-    private static void pushPoseFromTransformation(PoseStack stack, Transformation transformation) {
-        stack.pushPose();
-
-        var trans = transformation.getTranslation();
-        stack.translate(trans.x(), trans.y(), trans.z());
-
-        stack.mulPose(transformation.getLeftRotation());
-
-        var scale = transformation.getScale();
-        stack.scale(scale.x(), scale.y(), scale.z());
-
-        stack.mulPose(transformation.getRightRotation());
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/monitor/MonitorBlockEntityRenderer.java

@@ -1,289 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render.monitor;
-
-import com.mojang.blaze3d.platform.GlStateManager;
-import com.mojang.blaze3d.platform.MemoryTracker;
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.Tesselator;
-import com.mojang.blaze3d.vertex.VertexBuffer;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import com.mojang.math.Axis;
-import dan200.computercraft.client.FrameInfo;
-import dan200.computercraft.client.integration.ShaderMod;
-import dan200.computercraft.client.render.RenderTypes;
-import dan200.computercraft.client.render.text.DirectFixedWidthFontRenderer;
-import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
-import dan200.computercraft.client.render.vbo.DirectBuffers;
-import dan200.computercraft.client.render.vbo.DirectVertexBuffer;
-import dan200.computercraft.core.terminal.Terminal;
-import dan200.computercraft.shared.config.Config;
-import dan200.computercraft.shared.peripheral.monitor.ClientMonitor;
-import dan200.computercraft.shared.peripheral.monitor.MonitorBlockEntity;
-import dan200.computercraft.shared.peripheral.monitor.MonitorRenderer;
-import dan200.computercraft.shared.util.DirectionUtil;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
-import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
-import org.joml.Matrix3f;
-import org.joml.Matrix4f;
-import org.lwjgl.opengl.GL;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL20;
-import org.lwjgl.opengl.GL31;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.annotation.Nullable;
-import java.nio.ByteBuffer;
-import java.util.function.Consumer;
-
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_HEIGHT;
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.FONT_WIDTH;
-import static dan200.computercraft.core.util.Nullability.assertNonNull;
-
-public class MonitorBlockEntityRenderer implements BlockEntityRenderer<MonitorBlockEntity> {
-    private static final Logger LOG = LoggerFactory.getLogger(MonitorBlockEntityRenderer.class);
-
-    /**
-     * {@link MonitorBlockEntity#RENDER_MARGIN}, but a tiny bit of additional padding to ensure that there is no space between
-     * the monitor frame and contents.
-     */
-    private static final float MARGIN = (float) (MonitorBlockEntity.RENDER_MARGIN * 1.1);
-
-    private static final Matrix3f IDENTITY_NORMAL = new Matrix3f().identity();
-
-    private static @Nullable ByteBuffer backingBuffer;
-
-    public MonitorBlockEntityRenderer(BlockEntityRendererProvider.Context context) {
-    }
-
-    @Override
-    public void render(MonitorBlockEntity monitor, float partialTicks, PoseStack transform, MultiBufferSource bufferSource, int lightmapCoord, int overlayLight) {
-        // Render from the origin monitor
-        var originTerminal = monitor.getClientMonitor();
-
-        if (originTerminal == null) return;
-        var origin = originTerminal.getOrigin();
-        var renderState = originTerminal.getRenderState(MonitorRenderState::new);
-        var monitorPos = monitor.getBlockPos();
-
-        // Ensure each monitor terminal is rendered only once. We allow rendering a specific tile
-        // multiple times in a single frame to ensure compatibility with shaders which may run a
-        // pass multiple times.
-        var renderFrame = FrameInfo.getRenderFrame();
-        if (renderState.lastRenderFrame == renderFrame && !monitorPos.equals(renderState.lastRenderPos)) {
-            return;
-        }
-
-        renderState.lastRenderFrame = renderFrame;
-        renderState.lastRenderPos = monitorPos;
-
-        var originPos = origin.getBlockPos();
-
-        // Determine orientation
-        var dir = origin.getDirection();
-        var front = origin.getFront();
-        var yaw = dir.toYRot();
-        var pitch = DirectionUtil.toPitchAngle(front);
-
-        // Setup initial transform
-        transform.pushPose();
-        transform.translate(
-            originPos.getX() - monitorPos.getX() + 0.5,
-            originPos.getY() - monitorPos.getY() + 0.5,
-            originPos.getZ() - monitorPos.getZ() + 0.5
-        );
-
-        transform.mulPose(Axis.YN.rotationDegrees(yaw));
-        transform.mulPose(Axis.XP.rotationDegrees(pitch));
-        transform.translate(
-            -0.5 + MonitorBlockEntity.RENDER_BORDER + MonitorBlockEntity.RENDER_MARGIN,
-            origin.getHeight() - 0.5 - (MonitorBlockEntity.RENDER_BORDER + MonitorBlockEntity.RENDER_MARGIN) + 0,
-            0.5
-        );
-        var xSize = origin.getWidth() - 2.0 * (MonitorBlockEntity.RENDER_MARGIN + MonitorBlockEntity.RENDER_BORDER);
-        var ySize = origin.getHeight() - 2.0 * (MonitorBlockEntity.RENDER_MARGIN + MonitorBlockEntity.RENDER_BORDER);
-
-        // Draw the contents
-        var terminal = originTerminal.getTerminal();
-        if (terminal != null && !ShaderMod.get().isRenderingShadowPass()) {
-            // Draw a terminal
-            int width = terminal.getWidth(), height = terminal.getHeight();
-            int pixelWidth = width * FONT_WIDTH, pixelHeight = height * FONT_HEIGHT;
-            var xScale = xSize / pixelWidth;
-            var yScale = ySize / pixelHeight;
-            transform.pushPose();
-            transform.scale((float) xScale, (float) -yScale, 1.0f);
-
-            var matrix = transform.last().pose();
-
-            renderTerminal(matrix, originTerminal, renderState, terminal, (float) (MARGIN / xScale), (float) (MARGIN / yScale));
-
-            transform.popPose();
-        } else {
-            FixedWidthFontRenderer.drawEmptyTerminal(
-                FixedWidthFontRenderer.toVertexConsumer(transform, bufferSource.getBuffer(RenderTypes.TERMINAL)),
-                -MARGIN, MARGIN,
-                (float) (xSize + 2 * MARGIN), (float) -(ySize + MARGIN * 2)
-            );
-        }
-
-        transform.popPose();
-    }
-
-    private static void renderTerminal(
-        Matrix4f matrix, ClientMonitor monitor, MonitorRenderState renderState, Terminal terminal, float xMargin, float yMargin
-    ) {
-        int width = terminal.getWidth(), height = terminal.getHeight();
-        int pixelWidth = width * FONT_WIDTH, pixelHeight = height * FONT_HEIGHT;
-
-        var renderType = currentRenderer();
-        var redraw = monitor.pollTerminalChanged();
-        if (renderState.createBuffer(renderType)) redraw = true;
-
-        switch (renderType) {
-            case TBO -> {
-                if (redraw) {
-                    var terminalBuffer = getBuffer(width * height * 3);
-                    MonitorTextureBufferShader.setTerminalData(terminalBuffer, terminal);
-                    DirectBuffers.setBufferData(GL31.GL_TEXTURE_BUFFER, renderState.tboBuffer, terminalBuffer, GL20.GL_STATIC_DRAW);
-
-                    var uniformBuffer = getBuffer(MonitorTextureBufferShader.UNIFORM_SIZE);
-                    MonitorTextureBufferShader.setUniformData(uniformBuffer, terminal);
-                    DirectBuffers.setBufferData(GL31.GL_UNIFORM_BUFFER, renderState.tboUniform, uniformBuffer, GL20.GL_STATIC_DRAW);
-                }
-
-                // Nobody knows what they're doing!
-                var active = GlStateManager._getActiveTexture();
-                RenderSystem.activeTexture(MonitorTextureBufferShader.TEXTURE_INDEX);
-                GL11.glBindTexture(GL31.GL_TEXTURE_BUFFER, renderState.tboTexture);
-                RenderSystem.activeTexture(active);
-
-                var shader = RenderTypes.getMonitorTextureBufferShader();
-                shader.setupUniform(renderState.tboUniform);
-
-                var buffer = Tesselator.getInstance().getBuilder();
-                buffer.begin(RenderTypes.MONITOR_TBO.mode(), RenderTypes.MONITOR_TBO.format());
-                tboVertex(buffer, matrix, -xMargin, -yMargin);
-                tboVertex(buffer, matrix, -xMargin, pixelHeight + yMargin);
-                tboVertex(buffer, matrix, pixelWidth + xMargin, -yMargin);
-                tboVertex(buffer, matrix, pixelWidth + xMargin, pixelHeight + yMargin);
-                RenderTypes.MONITOR_TBO.end(buffer, 0, 0, 0);
-            }
-            case VBO -> {
-                var backgroundBuffer = assertNonNull(renderState.backgroundBuffer);
-                var foregroundBuffer = assertNonNull(renderState.foregroundBuffer);
-                if (redraw) {
-                    var size = DirectFixedWidthFontRenderer.getVertexCount(terminal);
-
-                    // In an ideal world we could upload these both into one buffer. However, we can't render VBOs with
-                    // and starting and ending offset, and so need to use two buffers instead.
-
-                    renderToBuffer(backgroundBuffer, size, sink ->
-                        DirectFixedWidthFontRenderer.drawTerminalBackground(sink, 0, 0, terminal, yMargin, yMargin, xMargin, xMargin));
-
-                    renderToBuffer(foregroundBuffer, size, sink -> {
-                        DirectFixedWidthFontRenderer.drawTerminalForeground(sink, 0, 0, terminal);
-                        // If the cursor is visible, we append it to the end of our buffer. When rendering, we can either
-                        // render n or n+1 quads and so toggle the cursor on and off.
-                        DirectFixedWidthFontRenderer.drawCursor(sink, 0, 0, terminal);
-                    });
-                }
-
-                // Our VBO doesn't transform its vertices with the provided pose stack, which means that the inverse view
-                // rotation matrix gives entirely wrong numbers for fog distances. We just set it to the identity which
-                // gives a good enough approximation.
-                var oldInverseRotation = RenderSystem.getInverseViewRotationMatrix();
-                RenderSystem.setInverseViewRotationMatrix(IDENTITY_NORMAL);
-
-                RenderTypes.TERMINAL.setupRenderState();
-
-                // Render background geometry
-                backgroundBuffer.bind();
-                backgroundBuffer.drawWithShader(matrix, RenderSystem.getProjectionMatrix(), RenderTypes.getTerminalShader());
-
-                // Render foreground geometry with glPolygonOffset enabled.
-                RenderSystem.polygonOffset(-1.0f, -10.0f);
-                RenderSystem.enablePolygonOffset();
-
-                foregroundBuffer.bind();
-                foregroundBuffer.drawWithShader(
-                    matrix, RenderSystem.getProjectionMatrix(), RenderTypes.getTerminalShader(),
-                    // As mentioned in the above comment, render the extra cursor quad if it is visible this frame. Each
-                    // // quad has an index count of 6.
-                    FixedWidthFontRenderer.isCursorVisible(terminal) && FrameInfo.getGlobalCursorBlink()
-                        ? foregroundBuffer.getIndexCount() + 6 : foregroundBuffer.getIndexCount()
-                );
-
-                // Clear state
-                RenderSystem.polygonOffset(0.0f, -0.0f);
-                RenderSystem.disablePolygonOffset();
-                RenderTypes.TERMINAL.clearRenderState();
-                VertexBuffer.unbind();
-
-                RenderSystem.setInverseViewRotationMatrix(oldInverseRotation);
-            }
-            case BEST -> throw new IllegalStateException("Impossible: Should never use BEST renderer");
-        }
-    }
-
-    private static void renderToBuffer(DirectVertexBuffer vbo, int size, Consumer<DirectFixedWidthFontRenderer.QuadEmitter> draw) {
-        var sink = ShaderMod.get().getQuadEmitter(size, MonitorBlockEntityRenderer::getBuffer);
-        var buffer = sink.buffer();
-
-        draw.accept(sink);
-        buffer.flip();
-        vbo.upload(buffer.limit() / sink.format().getVertexSize(), RenderTypes.TERMINAL.mode(), sink.format(), buffer);
-    }
-
-    private static void tboVertex(VertexConsumer builder, Matrix4f matrix, float x, float y) {
-        // We encode position in the UV, as that's not transformed by the matrix.
-        builder.vertex(matrix, x, y, 0).uv(x, y).endVertex();
-    }
-
-    private static ByteBuffer getBuffer(int capacity) {
-        var buffer = backingBuffer;
-        if (buffer == null || buffer.capacity() < capacity) {
-            buffer = backingBuffer = buffer == null ? MemoryTracker.create(capacity) : MemoryTracker.resize(buffer, capacity);
-        }
-
-        buffer.clear();
-        return buffer;
-    }
-
-    @Override
-    public int getViewDistance() {
-        return Config.monitorDistance;
-    }
-
-
-    /**
-     * Get the current renderer to use.
-     *
-     * @return The current renderer. Will not return {@link MonitorRenderer#BEST}.
-     */
-    public static MonitorRenderer currentRenderer() {
-        var current = Config.monitorRenderer;
-        if (current == MonitorRenderer.BEST) current = Config.monitorRenderer = bestRenderer();
-        return current;
-    }
-
-    private static MonitorRenderer bestRenderer() {
-        if (!GL.getCapabilities().OpenGL31) {
-            LOG.warn("Texture buffers are not supported on your graphics card. Falling back to VBO monitor renderer.");
-            return MonitorRenderer.VBO;
-        }
-
-        if (ShaderMod.get().isShaderMod()) {
-            LOG.warn("A shader mod is loaded, assuming shaders are being used. Falling back to VBO monitor renderer.");
-            return MonitorRenderer.VBO;
-        }
-
-        return MonitorRenderer.TBO;
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/monitor/MonitorHighlightRenderer.java

@@ -1,91 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render.monitor;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import dan200.computercraft.shared.peripheral.monitor.MonitorBlockEntity;
-import net.minecraft.client.Camera;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.core.Direction;
-import net.minecraft.world.phys.BlockHitResult;
-import org.joml.Matrix3f;
-import org.joml.Matrix4f;
-
-import java.util.EnumSet;
-
-import static net.minecraft.core.Direction.*;
-
-/**
- * Overrides monitor highlighting to only render the outline of the <em>whole</em> monitor, rather than the current
- * block. This means you do not get an intrusive outline on top of the screen.
- */
-public final class MonitorHighlightRenderer {
-    private MonitorHighlightRenderer() {
-    }
-
-    public static boolean drawHighlight(PoseStack transformStack, MultiBufferSource bufferSource, Camera camera, BlockHitResult hit) {
-        // Preserve normal behaviour when crouching.
-        if (camera.getEntity().isCrouching()) return false;
-
-        var world = camera.getEntity().getCommandSenderWorld();
-        var pos = hit.getBlockPos();
-
-        var tile = world.getBlockEntity(pos);
-        if (!(tile instanceof MonitorBlockEntity monitor)) return false;
-
-        // Determine which sides are part of the external faces of the monitor, and so which need to be rendered.
-        var faces = EnumSet.allOf(Direction.class);
-        var front = monitor.getFront();
-        faces.remove(front);
-        if (monitor.getXIndex() != 0) faces.remove(monitor.getRight().getOpposite());
-        if (monitor.getXIndex() != monitor.getWidth() - 1) faces.remove(monitor.getRight());
-        if (monitor.getYIndex() != 0) faces.remove(monitor.getDown().getOpposite());
-        if (monitor.getYIndex() != monitor.getHeight() - 1) faces.remove(monitor.getDown());
-
-        var cameraPos = camera.getPosition();
-        transformStack.pushPose();
-        transformStack.translate(pos.getX() - cameraPos.x(), pos.getY() - cameraPos.y(), pos.getZ() - cameraPos.z());
-
-        // I wish I could think of a better way to do this
-        var buffer = bufferSource.getBuffer(RenderType.lines());
-        var transform = transformStack.last().pose();
-        var normal = transformStack.last().normal();
-        if (faces.contains(NORTH) || faces.contains(WEST)) line(buffer, transform, normal, 0, 0, 0, UP);
-        if (faces.contains(SOUTH) || faces.contains(WEST)) line(buffer, transform, normal, 0, 0, 1, UP);
-        if (faces.contains(NORTH) || faces.contains(EAST)) line(buffer, transform, normal, 1, 0, 0, UP);
-        if (faces.contains(SOUTH) || faces.contains(EAST)) line(buffer, transform, normal, 1, 0, 1, UP);
-        if (faces.contains(NORTH) || faces.contains(DOWN)) line(buffer, transform, normal, 0, 0, 0, EAST);
-        if (faces.contains(SOUTH) || faces.contains(DOWN)) line(buffer, transform, normal, 0, 0, 1, EAST);
-        if (faces.contains(NORTH) || faces.contains(UP)) line(buffer, transform, normal, 0, 1, 0, EAST);
-        if (faces.contains(SOUTH) || faces.contains(UP)) line(buffer, transform, normal, 0, 1, 1, EAST);
-        if (faces.contains(WEST) || faces.contains(DOWN)) line(buffer, transform, normal, 0, 0, 0, SOUTH);
-        if (faces.contains(EAST) || faces.contains(DOWN)) line(buffer, transform, normal, 1, 0, 0, SOUTH);
-        if (faces.contains(WEST) || faces.contains(UP)) line(buffer, transform, normal, 0, 1, 0, SOUTH);
-        if (faces.contains(EAST) || faces.contains(UP)) line(buffer, transform, normal, 1, 1, 0, SOUTH);
-
-        transformStack.popPose();
-        return true;
-    }
-
-    private static void line(VertexConsumer buffer, Matrix4f transform, Matrix3f normal, float x, float y, float z, Direction direction) {
-        buffer
-            .vertex(transform, x, y, z)
-            .color(0, 0, 0, 0.4f)
-            .normal(normal, direction.getStepX(), direction.getStepY(), direction.getStepZ())
-            .endVertex();
-        buffer
-            .vertex(transform,
-                x + direction.getStepX(),
-                y + direction.getStepY(),
-                z + direction.getStepZ()
-            )
-            .color(0, 0, 0, 0.4f)
-            .normal(normal, direction.getStepX(), direction.getStepY(), direction.getStepZ())
-            .endVertex();
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/monitor/MonitorRenderState.java

@@ -1,132 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render.monitor;
-
-import com.google.errorprone.annotations.concurrent.GuardedBy;
-import com.mojang.blaze3d.platform.GlStateManager;
-import dan200.computercraft.client.render.vbo.DirectBuffers;
-import dan200.computercraft.client.render.vbo.DirectVertexBuffer;
-import dan200.computercraft.shared.peripheral.monitor.ClientMonitor;
-import dan200.computercraft.shared.peripheral.monitor.MonitorRenderer;
-import net.minecraft.core.BlockPos;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL15;
-import org.lwjgl.opengl.GL30;
-import org.lwjgl.opengl.GL31;
-
-import javax.annotation.Nullable;
-import java.util.HashSet;
-import java.util.Set;
-
-public class MonitorRenderState implements ClientMonitor.RenderState {
-    @GuardedBy("allMonitors")
-    private static final Set<MonitorRenderState> allMonitors = new HashSet<>();
-
-    public long lastRenderFrame = -1;
-    public @Nullable BlockPos lastRenderPos = null;
-
-    public int tboBuffer;
-    public int tboTexture;
-    public int tboUniform;
-    public @Nullable DirectVertexBuffer backgroundBuffer;
-    public @Nullable DirectVertexBuffer foregroundBuffer;
-
-    /**
-     * Create the appropriate buffer if needed.
-     *
-     * @param renderer The renderer to use.
-     * @return If a buffer was created. This will return {@code false} if we already have an appropriate buffer,
-     * or this mode does not require one.
-     */
-    public boolean createBuffer(MonitorRenderer renderer) {
-        switch (renderer) {
-            case TBO: {
-                if (tboBuffer != 0) return false;
-
-                deleteBuffers();
-
-                tboBuffer = DirectBuffers.createBuffer();
-                DirectBuffers.setEmptyBufferData(GL31.GL_TEXTURE_BUFFER, tboBuffer, GL15.GL_STATIC_DRAW);
-                tboTexture = GlStateManager._genTexture();
-                GL11.glBindTexture(GL31.GL_TEXTURE_BUFFER, tboTexture);
-                GL31.glTexBuffer(GL31.GL_TEXTURE_BUFFER, GL30.GL_R8UI, tboBuffer);
-                GL11.glBindTexture(GL31.GL_TEXTURE_BUFFER, 0);
-
-                tboUniform = DirectBuffers.createBuffer();
-                DirectBuffers.setEmptyBufferData(GL31.GL_UNIFORM_BUFFER, tboUniform, GL15.GL_STATIC_DRAW);
-
-                addMonitor();
-                return true;
-            }
-
-            case VBO:
-                if (backgroundBuffer != null) return false;
-
-                deleteBuffers();
-                backgroundBuffer = new DirectVertexBuffer();
-                foregroundBuffer = new DirectVertexBuffer();
-                addMonitor();
-                return true;
-
-            default:
-                return false;
-        }
-    }
-
-    private void addMonitor() {
-        synchronized (allMonitors) {
-            allMonitors.add(this);
-        }
-    }
-
-    private void deleteBuffers() {
-        if (tboBuffer != 0) {
-            DirectBuffers.deleteBuffer(GL31.GL_TEXTURE_BUFFER, tboBuffer);
-            tboBuffer = 0;
-        }
-
-        if (tboTexture != 0) {
-            GlStateManager._deleteTexture(tboTexture);
-            tboTexture = 0;
-        }
-
-        if (tboUniform != 0) {
-            DirectBuffers.deleteBuffer(GL31.GL_UNIFORM_BUFFER, tboUniform);
-            tboUniform = 0;
-        }
-
-        if (backgroundBuffer != null) {
-            backgroundBuffer.close();
-            backgroundBuffer = null;
-        }
-
-        if (foregroundBuffer != null) {
-            foregroundBuffer.close();
-            foregroundBuffer = null;
-        }
-    }
-
-    @Override
-    public void close() {
-        if (tboBuffer != 0 || backgroundBuffer != null) {
-            synchronized (allMonitors) {
-                allMonitors.remove(this);
-            }
-
-            deleteBuffers();
-        }
-    }
-
-    public static void destroyAll() {
-        synchronized (allMonitors) {
-            for (var iterator = allMonitors.iterator(); iterator.hasNext(); ) {
-                var monitor = iterator.next();
-                monitor.deleteBuffers();
-                iterator.remove();
-            }
-        }
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/monitor/MonitorTextureBufferShader.java

@@ -1,117 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render.monitor;
-
-import com.mojang.blaze3d.shaders.Uniform;
-import com.mojang.blaze3d.vertex.VertexFormat;
-import dan200.computercraft.client.FrameInfo;
-import dan200.computercraft.client.render.text.FixedWidthFontRenderer;
-import dan200.computercraft.core.terminal.Terminal;
-import dan200.computercraft.core.terminal.TextBuffer;
-import dan200.computercraft.core.util.Colour;
-import net.minecraft.client.renderer.ShaderInstance;
-import net.minecraft.server.packs.resources.ResourceProvider;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.lwjgl.opengl.GL13;
-import org.lwjgl.opengl.GL31;
-
-import javax.annotation.Nullable;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.getColour;
-
-public class MonitorTextureBufferShader extends ShaderInstance {
-    public static final int UNIFORM_SIZE = 4 * 4 * 16 + 4 + 4 + 2 * 4 + 4;
-
-    static final int TEXTURE_INDEX = GL13.GL_TEXTURE3;
-
-    private static final Logger LOGGER = LogManager.getLogger();
-
-    private final int monitorData;
-    private int uniformBuffer = 0;
-
-    private final @Nullable Uniform cursorBlink;
-
-    public MonitorTextureBufferShader(ResourceProvider provider, String location, VertexFormat format) throws IOException {
-        super(provider, location, format);
-        monitorData = GL31.glGetUniformBlockIndex(getId(), "MonitorData");
-        if (monitorData == -1) throw new IllegalStateException("Could not find MonitorData uniform.");
-
-        cursorBlink = getUniformChecked("CursorBlink");
-
-        var tbo = getUniformChecked("Tbo");
-        if (tbo != null) tbo.set(TEXTURE_INDEX - GL13.GL_TEXTURE0);
-    }
-
-    public void setupUniform(int buffer) {
-        uniformBuffer = buffer;
-
-        var cursorAlpha = FrameInfo.getGlobalCursorBlink() ? 1 : 0;
-        if (cursorBlink != null && cursorBlink.getIntBuffer().get(0) != cursorAlpha) cursorBlink.set(cursorAlpha);
-    }
-
-    @Override
-    public void apply() {
-        super.apply();
-        GL31.glBindBufferBase(GL31.GL_UNIFORM_BUFFER, monitorData, uniformBuffer);
-    }
-
-    @Nullable
-    private Uniform getUniformChecked(String name) {
-        var uniform = getUniform(name);
-        if (uniform == null) {
-            LOGGER.warn("Monitor shader {} should have uniform {}, but it was not present.", getName(), name);
-        }
-
-        return uniform;
-    }
-
-    public static void setTerminalData(ByteBuffer buffer, Terminal terminal) {
-        int width = terminal.getWidth(), height = terminal.getHeight();
-
-        var pos = 0;
-        for (var y = 0; y < height; y++) {
-            TextBuffer text = terminal.getLine(y), textColour = terminal.getTextColourLine(y), background = terminal.getBackgroundColourLine(y);
-            for (var x = 0; x < width; x++) {
-                buffer.put(pos, (byte) (text.charAt(x) & 0xFF));
-                buffer.put(pos + 1, (byte) getColour(textColour.charAt(x), Colour.WHITE));
-                buffer.put(pos + 2, (byte) getColour(background.charAt(x), Colour.BLACK));
-                pos += 3;
-            }
-        }
-
-        buffer.limit(pos);
-    }
-
-    public static void setUniformData(ByteBuffer buffer, Terminal terminal) {
-        var pos = 0;
-        var palette = terminal.getPalette();
-        for (var i = 0; i < 16; i++) {
-            {
-                var colour = palette.getColour(i);
-                if (!terminal.isColour()) {
-                    var f = FixedWidthFontRenderer.toGreyscale(colour);
-                    buffer.putFloat(pos, f).putFloat(pos + 4, f).putFloat(pos + 8, f);
-                } else {
-                    buffer.putFloat(pos, (float) colour[0]).putFloat(pos + 4, (float) colour[1]).putFloat(pos + 8, (float) colour[2]);
-                }
-            }
-
-            pos += 4 * 4; // std140 requires these are 4-wide
-        }
-
-        var showCursor = FixedWidthFontRenderer.isCursorVisible(terminal);
-        buffer
-            .putInt(pos, terminal.getWidth()).putInt(pos + 4, terminal.getHeight())
-            .putInt(pos + 8, showCursor ? terminal.getCursorX() : -2)
-            .putInt(pos + 12, showCursor ? terminal.getCursorY() : -2)
-            .putInt(pos + 16, 15 - terminal.getTextColour());
-
-        buffer.limit(UNIFORM_SIZE);
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/text/DirectFixedWidthFontRenderer.java

@@ -1,256 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render.text;
-
-import com.mojang.blaze3d.platform.MemoryTracker;
-import com.mojang.blaze3d.vertex.DefaultVertexFormat;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import com.mojang.blaze3d.vertex.VertexFormat;
-import dan200.computercraft.client.render.RenderTypes;
-import dan200.computercraft.core.terminal.Palette;
-import dan200.computercraft.core.terminal.Terminal;
-import dan200.computercraft.core.terminal.TextBuffer;
-import dan200.computercraft.core.util.Colour;
-import org.lwjgl.system.MemoryUtil;
-
-import java.nio.ByteBuffer;
-
-import static dan200.computercraft.client.render.text.FixedWidthFontRenderer.*;
-import static org.lwjgl.system.MemoryUtil.*;
-
-/**
- * An optimised copy of {@link FixedWidthFontRenderer} emitter emits directly to a {@link QuadEmitter} rather than
- * emitting to {@link VertexConsumer}. This allows us to emit vertices very quickly, when using the VBO renderer.
- * <p>
- * There are some limitations here:
- * <ul>
- *   <li>No transformation matrix (not needed for VBOs).</li>
- *   <li>Only works with {@link DefaultVertexFormat#POSITION_COLOR_TEX_LIGHTMAP}.</li>
- *   <li>The buffer <strong>MUST</strong> be allocated with {@link MemoryTracker}, and not through any other means.</li>
- * </ul>
- * <p>
- * Note this is almost an exact copy of {@link FixedWidthFontRenderer}. While the code duplication is unfortunate,
- * it is measurably faster than introducing polymorphism into {@link FixedWidthFontRenderer}.
- *
- * <strong>IMPORTANT: </strong> When making changes to this class, please check if you need to make the same changes to
- * {@link FixedWidthFontRenderer}.
- */
-public final class DirectFixedWidthFontRenderer {
-    private DirectFixedWidthFontRenderer() {
-    }
-
-    private static void drawChar(QuadEmitter emitter, float x, float y, int index, byte[] colour) {
-        // Short circuit to avoid the common case - the texture should be blank here after all.
-        if (index == '\0' || index == ' ') return;
-
-        var column = index % 16;
-        var row = index / 16;
-
-        var xStart = 1 + column * (FONT_WIDTH + 2);
-        var yStart = 1 + row * (FONT_HEIGHT + 2);
-
-        quad(
-            emitter, x, y, x + FONT_WIDTH, y + FONT_HEIGHT, 0, colour,
-            xStart / WIDTH, yStart / WIDTH, (xStart + FONT_WIDTH) / WIDTH, (yStart + FONT_HEIGHT) / WIDTH
-        );
-    }
-
-    private static void drawQuad(QuadEmitter emitter, float x, float y, float width, float height, Palette palette, char colourIndex) {
-        var colour = palette.getRenderColours(getColour(colourIndex, Colour.BLACK));
-        quad(emitter, x, y, x + width, y + height, 0f, colour, BACKGROUND_START, BACKGROUND_START, BACKGROUND_END, BACKGROUND_END);
-    }
-
-    private static void drawBackground(
-        QuadEmitter emitter, float x, float y, TextBuffer backgroundColour, Palette palette,
-        float leftMarginSize, float rightMarginSize, float height
-    ) {
-        if (leftMarginSize > 0) {
-            drawQuad(emitter, x - leftMarginSize, y, leftMarginSize, height, palette, backgroundColour.charAt(0));
-        }
-
-        if (rightMarginSize > 0) {
-            drawQuad(emitter, x + backgroundColour.length() * FONT_WIDTH, y, rightMarginSize, height, palette, backgroundColour.charAt(backgroundColour.length() - 1));
-        }
-
-        // Batch together runs of identical background cells.
-        var blockStart = 0;
-        var blockColour = '\0';
-        for (var i = 0; i < backgroundColour.length(); i++) {
-            var colourIndex = backgroundColour.charAt(i);
-            if (colourIndex == blockColour) continue;
-
-            if (blockColour != '\0') {
-                drawQuad(emitter, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (i - blockStart), height, palette, blockColour);
-            }
-
-            blockColour = colourIndex;
-            blockStart = i;
-        }
-
-        if (blockColour != '\0') {
-            drawQuad(emitter, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (backgroundColour.length() - blockStart), height, palette, blockColour);
-        }
-    }
-
-    public static void drawString(QuadEmitter emitter, float x, float y, TextBuffer text, TextBuffer textColour, Palette palette) {
-        for (var i = 0; i < text.length(); i++) {
-            var colour = palette.getRenderColours(getColour(textColour.charAt(i), Colour.BLACK));
-
-            int index = text.charAt(i);
-            if (index > 255) index = '?';
-            drawChar(emitter, x + i * FONT_WIDTH, y, index, colour);
-        }
-
-    }
-
-    public static void drawTerminalForeground(QuadEmitter emitter, float x, float y, Terminal terminal) {
-        var palette = terminal.getPalette();
-        var height = terminal.getHeight();
-
-        // The main text
-        for (var i = 0; i < height; i++) {
-            var rowY = y + FONT_HEIGHT * i;
-            drawString(
-                emitter, x, rowY, terminal.getLine(i), terminal.getTextColourLine(i),
-                palette
-            );
-        }
-    }
-
-    public static void drawTerminalBackground(
-        QuadEmitter emitter, float x, float y, Terminal terminal,
-        float topMarginSize, float bottomMarginSize, float leftMarginSize, float rightMarginSize
-    ) {
-        var palette = terminal.getPalette();
-        var height = terminal.getHeight();
-
-        // Top and bottom margins
-        drawBackground(
-            emitter, x, y - topMarginSize, terminal.getBackgroundColourLine(0), palette,
-            leftMarginSize, rightMarginSize, topMarginSize
-        );
-
-        drawBackground(
-            emitter, x, y + height * FONT_HEIGHT, terminal.getBackgroundColourLine(height - 1), palette,
-            leftMarginSize, rightMarginSize, bottomMarginSize
-        );
-
-        // The main text
-        for (var i = 0; i < height; i++) {
-            var rowY = y + FONT_HEIGHT * i;
-            drawBackground(
-                emitter, x, rowY, terminal.getBackgroundColourLine(i), palette,
-                leftMarginSize, rightMarginSize, FONT_HEIGHT
-            );
-        }
-    }
-
-    public static void drawCursor(QuadEmitter emitter, float x, float y, Terminal terminal) {
-        if (isCursorVisible(terminal)) {
-            var colour = terminal.getPalette().getRenderColours(15 - terminal.getTextColour());
-            drawChar(emitter, x + terminal.getCursorX() * FONT_WIDTH, y + terminal.getCursorY() * FONT_HEIGHT, '_', colour);
-        }
-    }
-
-    public static int getVertexCount(Terminal terminal) {
-        return (terminal.getHeight() + 2) * (terminal.getWidth() + 2) * 2;
-    }
-
-    private static void quad(QuadEmitter buffer, float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2) {
-        buffer.quad(x1, y1, x2, y2, z, rgba, u1, v1, u2, v2);
-    }
-
-    public interface QuadEmitter {
-        VertexFormat format();
-
-        ByteBuffer buffer();
-
-        void quad(float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2);
-    }
-
-    public record ByteBufferEmitter(ByteBuffer buffer) implements QuadEmitter {
-        @Override
-        public VertexFormat format() {
-            return RenderTypes.TERMINAL.format();
-        }
-
-        @Override
-        public void quad(float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2) {
-            DirectFixedWidthFontRenderer.quad(buffer, x1, y1, x2, y2, z, rgba, u1, v1, u2, v2);
-        }
-    }
-
-    static void quad(ByteBuffer buffer, float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2) {
-        // Emit a single quad to our buffer. This uses Unsafe (well, LWJGL's MemoryUtil) to directly blit bytes to the
-        // underlying buffer. This allows us to have a single bounds check up-front, rather than one for every write.
-        // This provides significant performance gains, at the cost of well, using Unsafe.
-        // Each vertex is 28 bytes, giving 112 bytes in total. Vertices are of the form (xyz:FFF)(rgba:BBBB)(uv1:FF)(uv2:SS),
-        // which matches the POSITION_COLOR_TEX_LIGHTMAP vertex format.
-
-        var position = buffer.position();
-        var addr = MemoryUtil.memAddress(buffer);
-
-        // We're doing terrible unsafe hacks below, so let's be really sure that what we're doing is reasonable.
-        if (position < 0 || 112 > buffer.limit() - position) throw new IndexOutOfBoundsException();
-        // Require the pointer to be aligned to a 32-bit boundary.
-        if ((addr & 3) != 0) throw new IllegalStateException("Memory is not aligned");
-        // Also assert the length of the array. This appears to help elide bounds checks on the array in some circumstances.
-        if (rgba.length != 4) throw new IllegalStateException();
-
-        memPutFloat(addr + 0, x1);
-        memPutFloat(addr + 4, y1);
-        memPutFloat(addr + 8, z);
-        memPutByte(addr + 12, rgba[0]);
-        memPutByte(addr + 13, rgba[1]);
-        memPutByte(addr + 14, rgba[2]);
-        memPutByte(addr + 15, (byte) 255);
-        memPutFloat(addr + 16, u1);
-        memPutFloat(addr + 20, v1);
-        memPutShort(addr + 24, (short) 0xF0);
-        memPutShort(addr + 26, (short) 0xF0);
-
-        memPutFloat(addr + 28, x1);
-        memPutFloat(addr + 32, y2);
-        memPutFloat(addr + 36, z);
-        memPutByte(addr + 40, rgba[0]);
-        memPutByte(addr + 41, rgba[1]);
-        memPutByte(addr + 42, rgba[2]);
-        memPutByte(addr + 43, (byte) 255);
-        memPutFloat(addr + 44, u1);
-        memPutFloat(addr + 48, v2);
-        memPutShort(addr + 52, (short) 0xF0);
-        memPutShort(addr + 54, (short) 0xF0);
-
-        memPutFloat(addr + 56, x2);
-        memPutFloat(addr + 60, y2);
-        memPutFloat(addr + 64, z);
-        memPutByte(addr + 68, rgba[0]);
-        memPutByte(addr + 69, rgba[1]);
-        memPutByte(addr + 70, rgba[2]);
-        memPutByte(addr + 71, (byte) 255);
-        memPutFloat(addr + 72, u2);
-        memPutFloat(addr + 76, v2);
-        memPutShort(addr + 80, (short) 0xF0);
-        memPutShort(addr + 82, (short) 0xF0);
-
-        memPutFloat(addr + 84, x2);
-        memPutFloat(addr + 88, y1);
-        memPutFloat(addr + 92, z);
-        memPutByte(addr + 96, rgba[0]);
-        memPutByte(addr + 97, rgba[1]);
-        memPutByte(addr + 98, rgba[2]);
-        memPutByte(addr + 99, (byte) 255);
-        memPutFloat(addr + 100, u2);
-        memPutFloat(addr + 104, v1);
-        memPutShort(addr + 108, (short) 0xF0);
-        memPutShort(addr + 110, (short) 0xF0);
-
-        // Finally increment the position.
-        buffer.position(position + 112);
-
-        // Well done for getting to the end of this method. I recommend you take a break and go look at cute puppies.
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/text/FixedWidthFontRenderer.java

@@ -1,230 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render.text;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import dan200.computercraft.client.FrameInfo;
-import dan200.computercraft.core.terminal.Palette;
-import dan200.computercraft.core.terminal.Terminal;
-import dan200.computercraft.core.terminal.TextBuffer;
-import dan200.computercraft.core.util.Colour;
-import net.minecraft.resources.ResourceLocation;
-import org.joml.Matrix4f;
-import org.joml.Vector3f;
-
-import static dan200.computercraft.client.render.RenderTypes.FULL_BRIGHT_LIGHTMAP;
-
-/**
- * Handles rendering fixed width text and computer terminals.
- * <p>
- * This class has several modes of usage:
- * <ul>
- * <li>{@link #drawString}: Drawing basic text without a terminal (such as for printouts). Unlike the other methods,
- * this accepts a lightmap coordinate as, unlike terminals, printed pages render fullbright.</li>
- * <li>{@link #drawTerminal}: Draw a terminal with a cursor. This is used by the various computer GUIs to render the
- * whole term.</li>
- * </ul>
- *
- * <strong>IMPORTANT: </strong> When making changes to this class, please check if you need to make the same changes to
- * {@link DirectFixedWidthFontRenderer}.
- */
-public final class FixedWidthFontRenderer {
-    public static final ResourceLocation FONT = new ResourceLocation("computercraft", "textures/gui/term_font.png");
-
-    public static final int FONT_HEIGHT = 9;
-    public static final int FONT_WIDTH = 6;
-    static final float WIDTH = 256.0f;
-
-    static final float BACKGROUND_START = (WIDTH - 6.0f) / WIDTH;
-    static final float BACKGROUND_END = (WIDTH - 4.0f) / WIDTH;
-
-    private static final byte[] BLACK = new byte[]{ byteColour(Colour.BLACK.getR()), byteColour(Colour.BLACK.getR()), byteColour(Colour.BLACK.getR()), (byte) 255 };
-    private static final float Z_OFFSET = 1e-3f;
-
-    private FixedWidthFontRenderer() {
-    }
-
-    private static byte byteColour(float c) {
-        return (byte) (int) (c * 255);
-    }
-
-    public static float toGreyscale(double[] rgb) {
-        return (float) ((rgb[0] + rgb[1] + rgb[2]) / 3);
-    }
-
-    public static int getColour(char c, Colour def) {
-        return 15 - Terminal.getColour(c, def);
-    }
-
-    private static void drawChar(QuadEmitter emitter, float x, float y, int index, byte[] colour, int light) {
-        // Short circuit to avoid the common case - the texture should be blank here after all.
-        if (index == '\0' || index == ' ') return;
-
-        var column = index % 16;
-        var row = index / 16;
-
-        var xStart = 1 + column * (FONT_WIDTH + 2);
-        var yStart = 1 + row * (FONT_HEIGHT + 2);
-
-        quad(
-            emitter, x, y, x + FONT_WIDTH, y + FONT_HEIGHT, 0, colour,
-            xStart / WIDTH, yStart / WIDTH, (xStart + FONT_WIDTH) / WIDTH, (yStart + FONT_HEIGHT) / WIDTH, light
-        );
-    }
-
-    public static void drawQuad(QuadEmitter emitter, float x, float y, float z, float width, float height, byte[] colour, int light) {
-        quad(emitter, x, y, x + width, y + height, z, colour, BACKGROUND_START, BACKGROUND_START, BACKGROUND_END, BACKGROUND_END, light);
-    }
-
-    private static void drawQuad(QuadEmitter emitter, float x, float y, float width, float height, Palette palette, char colourIndex, int light) {
-        var colour = palette.getRenderColours(getColour(colourIndex, Colour.BLACK));
-        drawQuad(emitter, x, y, 0, width, height, colour, light);
-    }
-
-    private static void drawBackground(
-        QuadEmitter emitter, float x, float y, TextBuffer backgroundColour, Palette palette,
-        float leftMarginSize, float rightMarginSize, float height, int light
-    ) {
-        if (leftMarginSize > 0) {
-            drawQuad(emitter, x - leftMarginSize, y, leftMarginSize, height, palette, backgroundColour.charAt(0), light);
-        }
-
-        if (rightMarginSize > 0) {
-            drawQuad(emitter, x + backgroundColour.length() * FONT_WIDTH, y, rightMarginSize, height, palette, backgroundColour.charAt(backgroundColour.length() - 1), light);
-        }
-
-        // Batch together runs of identical background cells.
-        var blockStart = 0;
-        var blockColour = '\0';
-        for (var i = 0; i < backgroundColour.length(); i++) {
-            var colourIndex = backgroundColour.charAt(i);
-            if (colourIndex == blockColour) continue;
-
-            if (blockColour != '\0') {
-                drawQuad(emitter, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (i - blockStart), height, palette, blockColour, light);
-            }
-
-            blockColour = colourIndex;
-            blockStart = i;
-        }
-
-        if (blockColour != '\0') {
-            drawQuad(emitter, x + blockStart * FONT_WIDTH, y, FONT_WIDTH * (backgroundColour.length() - blockStart), height, palette, blockColour, light);
-        }
-    }
-
-    public static void drawString(QuadEmitter emitter, float x, float y, TextBuffer text, TextBuffer textColour, Palette palette, int light) {
-        for (var i = 0; i < text.length(); i++) {
-            var colour = palette.getRenderColours(getColour(textColour.charAt(i), Colour.BLACK));
-
-            int index = text.charAt(i);
-            if (index > 255) index = '?';
-            drawChar(emitter, x + i * FONT_WIDTH, y, index, colour, light);
-        }
-
-    }
-
-    public static void drawTerminalForeground(QuadEmitter emitter, float x, float y, Terminal terminal) {
-        var palette = terminal.getPalette();
-        var height = terminal.getHeight();
-
-        // The main text
-        for (var i = 0; i < height; i++) {
-            var rowY = y + FONT_HEIGHT * i;
-            drawString(
-                emitter, x, rowY, terminal.getLine(i), terminal.getTextColourLine(i),
-                palette, FULL_BRIGHT_LIGHTMAP
-            );
-        }
-    }
-
-    public static void drawTerminalBackground(
-        QuadEmitter emitter, float x, float y, Terminal terminal,
-        float topMarginSize, float bottomMarginSize, float leftMarginSize, float rightMarginSize
-    ) {
-        var palette = terminal.getPalette();
-        var height = terminal.getHeight();
-
-        // Top and bottom margins
-        drawBackground(
-            emitter, x, y - topMarginSize, terminal.getBackgroundColourLine(0), palette,
-            leftMarginSize, rightMarginSize, topMarginSize, FULL_BRIGHT_LIGHTMAP
-        );
-
-        drawBackground(
-            emitter, x, y + height * FONT_HEIGHT, terminal.getBackgroundColourLine(height - 1), palette,
-            leftMarginSize, rightMarginSize, bottomMarginSize, FULL_BRIGHT_LIGHTMAP
-        );
-
-        // The main text
-        for (var i = 0; i < height; i++) {
-            var rowY = y + FONT_HEIGHT * i;
-            drawBackground(
-                emitter, x, rowY, terminal.getBackgroundColourLine(i), palette,
-                leftMarginSize, rightMarginSize, FONT_HEIGHT, FULL_BRIGHT_LIGHTMAP
-            );
-        }
-    }
-
-    public static boolean isCursorVisible(Terminal terminal) {
-        if (!terminal.getCursorBlink()) return false;
-
-        var cursorX = terminal.getCursorX();
-        var cursorY = terminal.getCursorY();
-        return cursorX >= 0 && cursorX < terminal.getWidth() && cursorY >= 0 && cursorY < terminal.getHeight();
-    }
-
-    public static void drawCursor(QuadEmitter emitter, float x, float y, Terminal terminal) {
-        if (isCursorVisible(terminal) && FrameInfo.getGlobalCursorBlink()) {
-            var colour = terminal.getPalette().getRenderColours(15 - terminal.getTextColour());
-            drawChar(emitter, x + terminal.getCursorX() * FONT_WIDTH, y + terminal.getCursorY() * FONT_HEIGHT, '_', colour, FULL_BRIGHT_LIGHTMAP);
-        }
-    }
-
-    public static void drawTerminal(
-        QuadEmitter emitter, float x, float y, Terminal terminal,
-        float topMarginSize, float bottomMarginSize, float leftMarginSize, float rightMarginSize
-    ) {
-        drawTerminalBackground(
-            emitter, x, y, terminal,
-            topMarginSize, bottomMarginSize, leftMarginSize, rightMarginSize
-        );
-
-        // Render the foreground with a slight offset. By calling .translate() on the matrix itself, we're translating
-        // in screen space, rather than in model/view space.
-        // It's definitely not perfect, but better than z fighting!
-        var transformBackup = new Matrix4f(emitter.poseMatrix());
-        emitter.poseMatrix().translate(new Vector3f(0, 0, Z_OFFSET));
-
-        drawTerminalForeground(emitter, x, y, terminal);
-        drawCursor(emitter, x, y, terminal);
-
-        emitter.poseMatrix().set(transformBackup);
-    }
-
-    public static void drawEmptyTerminal(QuadEmitter emitter, float x, float y, float width, float height) {
-        drawQuad(emitter, x, y, 0, width, height, BLACK, FULL_BRIGHT_LIGHTMAP);
-    }
-
-    public record QuadEmitter(Matrix4f poseMatrix, VertexConsumer consumer) {
-    }
-
-    public static QuadEmitter toVertexConsumer(PoseStack transform, VertexConsumer consumer) {
-        return new QuadEmitter(transform.last().pose(), consumer);
-    }
-
-    private static void quad(QuadEmitter c, float x1, float y1, float x2, float y2, float z, byte[] rgba, float u1, float v1, float u2, float v2, int light) {
-        var poseMatrix = c.poseMatrix();
-        var consumer = c.consumer();
-        byte r = rgba[0], g = rgba[1], b = rgba[2], a = rgba[3];
-
-        consumer.vertex(poseMatrix, x1, y1, z).color(r, g, b, a).uv(u1, v1).uv2(light).endVertex();
-        consumer.vertex(poseMatrix, x1, y2, z).color(r, g, b, a).uv(u1, v2).uv2(light).endVertex();
-        consumer.vertex(poseMatrix, x2, y2, z).color(r, g, b, a).uv(u2, v2).uv2(light).endVertex();
-        consumer.vertex(poseMatrix, x2, y1, z).color(r, g, b, a).uv(u2, v1).uv2(light).endVertex();
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/render/vbo/DirectVertexBuffer.java

@@ -1,77 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.render.vbo;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.BufferUploader;
-import com.mojang.blaze3d.vertex.VertexBuffer;
-import com.mojang.blaze3d.vertex.VertexFormat;
-import net.minecraft.client.renderer.ShaderInstance;
-import org.joml.Matrix4f;
-import org.lwjgl.opengl.GL15;
-import org.lwjgl.opengl.GL15C;
-import org.lwjgl.opengl.GL45C;
-
-import java.nio.ByteBuffer;
-
-/**
- * A version of {@link VertexBuffer} which allows uploading {@link ByteBuffer}s directly.
- * <p>
- * This should probably be its own class (rather than subclassing), but I need access to {@link VertexBuffer#drawWithShader}.
- */
-public class DirectVertexBuffer extends VertexBuffer {
-    private int actualIndexCount;
-
-    public DirectVertexBuffer() {
-        if (DirectBuffers.HAS_DSA) {
-            RenderSystem.glDeleteBuffers(vertexBufferId);
-            if (DirectBuffers.ON_LINUX) BufferUploader.reset(); // See comment on DirectBuffers.deleteBuffer.
-            vertexBufferId = GL45C.glCreateBuffers();
-        }
-    }
-
-    public void upload(int vertexCount, VertexFormat.Mode mode, VertexFormat format, ByteBuffer buffer) {
-        bind();
-
-        this.mode = mode;
-        actualIndexCount = indexCount = mode.indexCount(vertexCount);
-        indexType = VertexFormat.IndexType.SHORT;
-
-        RenderSystem.assertOnRenderThread();
-
-        DirectBuffers.setBufferData(GL15.GL_ARRAY_BUFFER, vertexBufferId, buffer, GL15.GL_STATIC_DRAW);
-        if (format != this.format) {
-            if (this.format != null) this.format.clearBufferState();
-            this.format = format;
-
-            GL15C.glBindBuffer(GL15C.GL_ARRAY_BUFFER, vertexBufferId);
-            format.setupBufferState();
-            GL15C.glBindBuffer(GL15C.GL_ARRAY_BUFFER, 0);
-        }
-
-        var indexBuffer = RenderSystem.getSequentialBuffer(mode);
-        if (indexBuffer != sequentialIndices || !indexBuffer.hasStorage(indexCount)) {
-            indexBuffer.bind(indexCount);
-            sequentialIndices = indexBuffer;
-        }
-    }
-
-    public void drawWithShader(Matrix4f modelView, Matrix4f projection, ShaderInstance shader, int indexCount) {
-        this.indexCount = indexCount;
-        drawWithShader(modelView, projection, shader);
-        this.indexCount = actualIndexCount;
-    }
-
-    public int getIndexCount() {
-        return actualIndexCount;
-    }
-
-    @Override
-    public void close() {
-        super.close();
-        if (DirectBuffers.ON_LINUX) BufferUploader.reset(); // See comment on DirectBuffers.deleteBuffer.
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/sound/DfpwmStream.java

@@ -1,139 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.sound;
-
-import com.mojang.blaze3d.audio.Channel;
-import dan200.computercraft.shared.peripheral.speaker.SpeakerPeripheral;
-import io.netty.buffer.ByteBuf;
-import net.minecraft.client.sounds.AudioStream;
-import net.minecraft.client.sounds.SoundEngine;
-import org.lwjgl.BufferUtils;
-
-import javax.annotation.Nullable;
-import javax.sound.sampled.AudioFormat;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.util.ArrayDeque;
-import java.util.Queue;
-import java.util.concurrent.Executor;
-
-class DfpwmStream implements AudioStream {
-    private static final int PREC = 10;
-    private static final int LPF_STRENGTH = 140;
-
-    private static final AudioFormat MONO_8 = new AudioFormat(SpeakerPeripheral.SAMPLE_RATE, 8, 1, true, false);
-
-    private final Queue<ByteBuffer> buffers = new ArrayDeque<>(2);
-
-    /**
-     * The {@link Channel} which this sound is playing on.
-     *
-     * @see SpeakerInstance#pushAudio(ByteBuf)
-     */
-    @Nullable
-    Channel channel;
-
-    /**
-     * The underlying {@link SoundEngine} executor.
-     *
-     * @see SpeakerInstance#pushAudio(ByteBuf)
-     * @see SoundEngine#executor
-     */
-    @Nullable
-    Executor executor;
-
-    private int charge = 0; // q
-    private int strength = 0; // s
-    private int lowPassCharge;
-    private boolean previousBit = false;
-
-    DfpwmStream() {
-    }
-
-    void push(ByteBuf input) {
-        var readable = input.readableBytes();
-        var output = ByteBuffer.allocate(readable * 8).order(ByteOrder.nativeOrder());
-
-        for (var i = 0; i < readable; i++) {
-            var inputByte = input.readByte();
-            for (var j = 0; j < 8; j++) {
-                var currentBit = (inputByte & 1) != 0;
-                var target = currentBit ? 127 : -128;
-
-                // q' <- q + (s * (t - q) + 128)/256
-                var nextCharge = charge + ((strength * (target - charge) + (1 << (PREC - 1))) >> PREC);
-                if (nextCharge == charge && nextCharge != target) nextCharge += currentBit ? 1 : -1;
-
-                var z = currentBit == previousBit ? (1 << PREC) - 1 : 0;
-
-                var nextStrength = strength;
-                if (strength != z) nextStrength += currentBit == previousBit ? 1 : -1;
-                if (nextStrength < 2 << (PREC - 8)) nextStrength = 2 << (PREC - 8);
-
-                // Apply antijerk
-                var chargeWithAntijerk = currentBit == previousBit
-                    ? nextCharge
-                    : nextCharge + charge + 1 >> 1;
-
-                // And low pass filter: outQ <- outQ + ((expectedOutput - outQ) x 140 / 256)
-                lowPassCharge += ((chargeWithAntijerk - lowPassCharge) * LPF_STRENGTH + 0x80) >> 8;
-
-                charge = nextCharge;
-                strength = nextStrength;
-                previousBit = currentBit;
-
-                // OpenAL expects signed data ([0, 255]) while we produce unsigned ([-128, 127]). Do some bit twiddling
-                // magic to convert.
-                output.put((byte) ((lowPassCharge & 0xFF) ^ 0x80));
-
-                inputByte >>= 1;
-            }
-        }
-
-        output.flip();
-        synchronized (this) {
-            buffers.add(output);
-        }
-    }
-
-    @Override
-    public AudioFormat getFormat() {
-        return MONO_8;
-    }
-
-    @Nullable
-    @Override
-    public synchronized ByteBuffer read(int capacity) {
-        var result = BufferUtils.createByteBuffer(capacity);
-        while (result.hasRemaining()) {
-            var head = buffers.peek();
-            if (head == null) break;
-
-            var toRead = Math.min(head.remaining(), result.remaining());
-            result.put(result.position(), head, head.position(), toRead);
-            result.position(result.position() + toRead);
-            head.position(head.position() + toRead);
-
-            if (head.hasRemaining()) break;
-            buffers.remove();
-        }
-
-        result.flip();
-
-        // This is naughty, but ensures we're not enqueuing empty buffers when the stream is exhausted.
-        return result.remaining() == 0 ? null : result;
-    }
-
-    @Override
-    public void close() throws IOException {
-        buffers.clear();
-    }
-
-    public boolean isEmpty() {
-        return buffers.isEmpty();
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/sound/SpeakerInstance.java

@@ -1,86 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.sound;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.core.util.Nullability;
-import dan200.computercraft.shared.peripheral.speaker.SpeakerPosition;
-import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
-import net.minecraft.resources.ResourceLocation;
-
-import javax.annotation.Nullable;
-
-/**
- * An instance of a speaker, which is either playing a {@link DfpwmStream} stream or a normal sound.
- */
-public class SpeakerInstance {
-    public static final ResourceLocation DFPWM_STREAM = new ResourceLocation(ComputerCraftAPI.MOD_ID, "speaker.dfpwm_fake_audio_should_not_be_played");
-
-    private @Nullable DfpwmStream currentStream;
-    private @Nullable SpeakerSound sound;
-
-    SpeakerInstance() {
-    }
-
-    public synchronized void pushAudio(ByteBuf buffer) {
-        var sound = this.sound;
-
-        var stream = currentStream;
-        if (stream == null) stream = currentStream = new DfpwmStream();
-        var exhausted = stream.isEmpty();
-        stream.push(buffer);
-
-        // If we've got nothing left in the buffer, enqueue an additional one just in case.
-        if (exhausted && sound != null && sound.stream == stream && stream.channel != null && stream.executor != null) {
-            var actualStream = sound.stream;
-            stream.executor.execute(() -> {
-                var channel = Nullability.assertNonNull(actualStream.channel);
-                if (!channel.stopped()) channel.pumpBuffers(1);
-            });
-        }
-    }
-
-    public void playAudio(SpeakerPosition position, float volume) {
-        var soundManager = Minecraft.getInstance().getSoundManager();
-
-        if (sound != null && sound.stream != currentStream) {
-            soundManager.stop(sound);
-            sound = null;
-        }
-
-        if (sound != null && !soundManager.isActive(sound)) sound = null;
-
-        if (sound == null && currentStream != null) {
-            sound = new SpeakerSound(DFPWM_STREAM, currentStream, position, volume, 1.0f);
-            soundManager.play(sound);
-        }
-    }
-
-    public void playSound(SpeakerPosition position, ResourceLocation location, float volume, float pitch) {
-        var soundManager = Minecraft.getInstance().getSoundManager();
-        currentStream = null;
-
-        if (sound != null) {
-            soundManager.stop(sound);
-            sound = null;
-        }
-
-        sound = new SpeakerSound(location, null, position, volume, pitch);
-        soundManager.play(sound);
-    }
-
-    void setPosition(SpeakerPosition position) {
-        if (sound != null) sound.setPosition(position);
-    }
-
-    void stop() {
-        if (sound != null) Minecraft.getInstance().getSoundManager().stop(sound);
-
-        currentStream = null;
-        sound = null;
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/sound/SpeakerManager.java

@@ -1,48 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.sound;
-
-import com.mojang.blaze3d.audio.Channel;
-import dan200.computercraft.shared.peripheral.speaker.SpeakerPosition;
-import net.minecraft.client.sounds.AudioStream;
-import net.minecraft.client.sounds.SoundEngine;
-
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Maps speakers source IDs to a {@link SpeakerInstance}.
- */
-public class SpeakerManager {
-    private static final Map<UUID, SpeakerInstance> sounds = new ConcurrentHashMap<>();
-
-    public static void onPlayStreaming(SoundEngine engine, Channel channel, AudioStream stream) {
-        if (!(stream instanceof DfpwmStream dfpwmStream)) return;
-
-        // Associate the stream with the current channel, so SpeakerInstance.pushAudio can queue audio immediately.
-        dfpwmStream.channel = channel;
-        dfpwmStream.executor = engine.executor;
-    }
-
-    public static SpeakerInstance getSound(UUID source) {
-        return sounds.computeIfAbsent(source, x -> new SpeakerInstance());
-    }
-
-    public static void stopSound(UUID source) {
-        var sound = sounds.remove(source);
-        if (sound != null) sound.stop();
-    }
-
-    public static void moveSound(UUID source, SpeakerPosition position) {
-        var sound = sounds.get(source);
-        if (sound != null) sound.setPosition(position);
-    }
-
-    public static void reset() {
-        sounds.clear();
-    }
-}

projects/common/src/client/java/dan200/computercraft/client/turtle/TurtleModemModeller.java

@@ -1,49 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.client.turtle;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.client.TransformedModel;
-import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
-import dan200.computercraft.api.turtle.ITurtleAccess;
-import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.shared.turtle.upgrades.TurtleModem;
-import net.minecraft.resources.ResourceLocation;
-import org.jetbrains.annotations.Nullable;
-
-public class TurtleModemModeller implements TurtleUpgradeModeller<TurtleModem> {
-    private final ResourceLocation leftOffModel;
-    private final ResourceLocation rightOffModel;
-    private final ResourceLocation leftOnModel;
-    private final ResourceLocation rightOnModel;
-
-    public TurtleModemModeller(boolean advanced) {
-        if (advanced) {
-            leftOffModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_advanced_off_left");
-            rightOffModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_advanced_off_right");
-            leftOnModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_advanced_on_left");
-            rightOnModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_advanced_on_right");
-        } else {
-            leftOffModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_normal_off_left");
-            rightOffModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_normal_off_right");
-            leftOnModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_normal_on_left");
-            rightOnModel = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_modem_normal_on_right");
-        }
-    }
-
-    @Override
-    public TransformedModel getModel(TurtleModem upgrade, @Nullable ITurtleAccess turtle, TurtleSide side) {
-        var active = false;
-        if (turtle != null) {
-            var turtleNBT = turtle.getUpgradeNBTData(side);
-            active = turtleNBT.contains("active") && turtleNBT.getBoolean("active");
-        }
-
-        return side == TurtleSide.LEFT
-            ? TransformedModel.of(active ? leftOnModel : leftOffModel)
-            : TransformedModel.of(active ? rightOnModel : rightOffModel);
-    }
-}

projects/common/src/client/java/dan200/computercraft/mixin/client/ClientPacketListenerMixin.java

@@ -1,21 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.mixin.client;
-
-import dan200.computercraft.client.ClientHooks;
-import net.minecraft.client.multiplayer.ClientPacketListener;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(ClientPacketListener.class)
-class ClientPacketListenerMixin {
-    @Inject(method = "sendUnsignedCommand", at = @At("HEAD"), cancellable = true)
-    void commandUnsigned(String message, CallbackInfoReturnable<Boolean> ci) {
-        if (ClientHooks.onChatMessage(message)) ci.setReturnValue(true);
-    }
-}

projects/common/src/client/resources/computercraft-client.mixins.json

@@ -1,13 +0,0 @@
-{
-    "required": true,
-    "package": "dan200.computercraft.mixin.client",
-    "minVersion": "0.8",
-    "compatibilityLevel": "JAVA_17",
-    "injectors": {
-        "defaultRequire": 1
-    },
-    "client": [
-        "ClientPacketListenerMixin"
-    ],
-    "refmap": "client-computercraft.refmap.json"
-}

projects/common/src/main/java/dan200/computercraft/annotations/FabricOverride.java

@@ -1,17 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.annotations;
-
-import java.lang.annotation.*;
-
-/**
- * Equivalent to {@link Override}, but for Fabric-specific methods.
- */
-@Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target(ElementType.METHOD)
-public @interface FabricOverride {
-}

projects/common/src/main/java/dan200/computercraft/annotations/ForgeOverride.java

@@ -1,17 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.annotations;
-
-import java.lang.annotation.*;
-
-/**
- * Equivalent to {@link Override}, but for Forge-specific methods.
- */
-@Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target(ElementType.METHOD)
-public @interface ForgeOverride {
-}

projects/common/src/main/java/dan200/computercraft/data/BlockModelProvider.java

@@ -1,417 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.computer.blocks.ComputerBlock;
-import dan200.computercraft.shared.peripheral.diskdrive.DiskDriveBlock;
-import dan200.computercraft.shared.peripheral.modem.wired.CableBlock;
-import dan200.computercraft.shared.peripheral.modem.wired.CableModemVariant;
-import dan200.computercraft.shared.peripheral.modem.wired.WiredModemFullBlock;
-import dan200.computercraft.shared.peripheral.modem.wireless.WirelessModemBlock;
-import dan200.computercraft.shared.peripheral.monitor.MonitorBlock;
-import dan200.computercraft.shared.peripheral.monitor.MonitorEdgeState;
-import dan200.computercraft.shared.peripheral.printer.PrinterBlock;
-import dan200.computercraft.shared.turtle.blocks.TurtleBlock;
-import dan200.computercraft.shared.util.DirectionUtil;
-import net.minecraft.core.Direction;
-import net.minecraft.data.models.BlockModelGenerators;
-import net.minecraft.data.models.blockstates.*;
-import net.minecraft.data.models.model.*;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.block.state.properties.BlockStateProperties;
-import net.minecraft.world.level.block.state.properties.BooleanProperty;
-import net.minecraft.world.level.block.state.properties.Property;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-import static net.minecraft.data.models.model.ModelLocationUtils.getModelLocation;
-import static net.minecraft.data.models.model.TextureMapping.getBlockTexture;
-
-class BlockModelProvider {
-    private static final ModelTemplate MONITOR_BASE = new ModelTemplate(
-        Optional.of(new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/monitor_base")),
-        Optional.empty(),
-        TextureSlot.FRONT, TextureSlot.SIDE, TextureSlot.TOP, TextureSlot.BACK
-    );
-    private static final ModelTemplate MODEM = new ModelTemplate(
-        Optional.of(new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/modem")),
-        Optional.empty(),
-        TextureSlot.FRONT, TextureSlot.BACK
-    );
-    private static final ModelTemplate TURTLE = new ModelTemplate(
-        Optional.of(new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_base")),
-        Optional.empty(),
-        TextureSlot.TEXTURE
-    );
-    private static final ModelTemplate TURTLE_UPGRADE_LEFT = new ModelTemplate(
-        Optional.of(new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_upgrade_base_left")),
-        Optional.of("_left"),
-        TextureSlot.TEXTURE
-    );
-    private static final ModelTemplate TURTLE_UPGRADE_RIGHT = new ModelTemplate(
-        Optional.of(new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/turtle_upgrade_base_right")),
-        Optional.of("_left"),
-        TextureSlot.TEXTURE
-    );
-
-    public static void addBlockModels(BlockModelGenerators generators) {
-        registerComputer(generators, ModRegistry.Blocks.COMPUTER_NORMAL.get());
-        registerComputer(generators, ModRegistry.Blocks.COMPUTER_ADVANCED.get());
-        registerComputer(generators, ModRegistry.Blocks.COMPUTER_COMMAND.get());
-
-        registerTurtle(generators, ModRegistry.Blocks.TURTLE_NORMAL.get());
-        registerTurtle(generators, ModRegistry.Blocks.TURTLE_ADVANCED.get());
-
-        registerWirelessModem(generators, ModRegistry.Blocks.WIRELESS_MODEM_NORMAL.get());
-        registerWirelessModem(generators, ModRegistry.Blocks.WIRELESS_MODEM_ADVANCED.get());
-
-        registerWiredModems(generators);
-
-        registerMonitor(generators, ModRegistry.Blocks.MONITOR_NORMAL.get());
-        registerMonitor(generators, ModRegistry.Blocks.MONITOR_ADVANCED.get());
-
-        generators.createHorizontallyRotatedBlock(ModRegistry.Blocks.SPEAKER.get(), TexturedModel.ORIENTABLE_ONLY_TOP);
-        registerDiskDrive(generators);
-        registerPrinter(generators);
-
-        registerCable(generators);
-
-        registerTurtleUpgrade(generators, "block/turtle_crafting_table", "block/turtle_crafty_face");
-        registerTurtleUpgrade(generators, "block/turtle_speaker", "block/turtle_speaker_face");
-        registerTurtleModem(generators, "block/turtle_modem_normal", "block/wireless_modem_normal_face");
-        registerTurtleModem(generators, "block/turtle_modem_advanced", "block/wireless_modem_advanced_face");
-    }
-
-    private static void registerDiskDrive(BlockModelGenerators generators) {
-        var diskDrive = ModRegistry.Blocks.DISK_DRIVE.get();
-        generators.blockStateOutput.accept(MultiVariantGenerator.multiVariant(diskDrive)
-            .with(createHorizontalFacingDispatch())
-            .with(createModelDispatch(DiskDriveBlock.STATE, value -> {
-                var textureSuffix = switch (value) {
-                    case EMPTY -> "_front";
-                    case INVALID -> "_front_rejected";
-                    case FULL -> "_front_accepted";
-                };
-                return ModelTemplates.CUBE_ORIENTABLE.createWithSuffix(
-                    diskDrive, "_" + value.getSerializedName(),
-                    TextureMapping.orientableCube(diskDrive).put(TextureSlot.FRONT, getBlockTexture(diskDrive, textureSuffix)),
-                    generators.modelOutput
-                );
-            }))
-        );
-        generators.delegateItemModel(diskDrive, getModelLocation(diskDrive, "_empty"));
-    }
-
-    private static void registerPrinter(BlockModelGenerators generators) {
-        var printer = ModRegistry.Blocks.PRINTER.get();
-        generators.blockStateOutput.accept(MultiVariantGenerator.multiVariant(printer)
-            .with(createHorizontalFacingDispatch())
-            .with(createModelDispatch(PrinterBlock.TOP, PrinterBlock.BOTTOM, (top, bottom) -> {
-                String model, texture;
-                if (top && bottom) {
-                    model = "_both_full";
-                    texture = "_both_trays";
-                } else if (top) {
-                    model = "_top_full";
-                    texture = "_top_tray";
-                } else if (bottom) {
-                    model = "_bottom_full";
-                    texture = "_bottom_tray";
-                } else {
-                    texture = model = "_empty";
-                }
-
-                return ModelTemplates.CUBE_ORIENTABLE.createWithSuffix(printer, model,
-                    TextureMapping.orientableCube(printer).put(TextureSlot.FRONT, getBlockTexture(printer, "_front" + texture)),
-                    generators.modelOutput
-                );
-            }))
-        );
-        generators.delegateItemModel(printer, getModelLocation(printer, "_empty"));
-    }
-
-    private static void registerComputer(BlockModelGenerators generators, ComputerBlock<?> block) {
-        generators.blockStateOutput.accept(MultiVariantGenerator.multiVariant(block)
-            .with(createHorizontalFacingDispatch())
-            .with(createModelDispatch(ComputerBlock.STATE, state -> ModelTemplates.CUBE_ORIENTABLE.createWithSuffix(
-                block, "_" + state.getSerializedName(),
-                TextureMapping.orientableCube(block).put(TextureSlot.FRONT, getBlockTexture(block, "_front" + state.getTexture())),
-                generators.modelOutput
-            )))
-        );
-        generators.delegateItemModel(block, getModelLocation(block, "_blinking"));
-    }
-
-    private static void registerTurtle(BlockModelGenerators generators, TurtleBlock block) {
-        var model = TURTLE.create(block, TextureMapping.defaultTexture(block), generators.modelOutput);
-        generators.blockStateOutput.accept(
-            MultiVariantGenerator.multiVariant(block, Variant.variant().with(VariantProperties.MODEL, model))
-                .with(createHorizontalFacingDispatch())
-        );
-
-        generators.modelOutput.accept(getModelLocation(block.asItem()), () -> {
-            var out = new JsonObject();
-            out.addProperty("loader", "computercraft:turtle");
-            out.addProperty("model", model.toString());
-            return out;
-        });
-    }
-
-    private static void registerWirelessModem(BlockModelGenerators generators, WirelessModemBlock block) {
-        generators.blockStateOutput.accept(MultiVariantGenerator.multiVariant(block)
-            .with(createFacingDispatch())
-            .with(createModelDispatch(WirelessModemBlock.ON,
-                on -> modemModel(generators, getModelLocation(block, on ? "_on" : "_off"), getBlockTexture(block, "_face" + (on ? "_on" : "")))
-            )));
-        generators.delegateItemModel(block, getModelLocation(block, "_off"));
-    }
-
-    private static void registerWiredModems(BlockModelGenerators generators) {
-        var fullBlock = ModRegistry.Blocks.WIRED_MODEM_FULL.get();
-        generators.blockStateOutput.accept(MultiVariantGenerator.multiVariant(fullBlock)
-            .with(createModelDispatch(WiredModemFullBlock.MODEM_ON, WiredModemFullBlock.PERIPHERAL_ON, (on, peripheral) -> {
-                var suffix = (on ? "_on" : "_off") + (peripheral ? "_peripheral" : "");
-                var faceTexture = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/wired_modem_face" + (peripheral ? "_peripheral" : "") + (on ? "_on" : ""));
-
-                // TODO: Do this somewhere more elegant!
-                modemModel(generators, new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/wired_modem" + suffix), faceTexture);
-
-                return ModelTemplates.CUBE_ALL.create(
-                    getModelLocation(fullBlock, suffix),
-                    new TextureMapping().put(TextureSlot.ALL, faceTexture),
-                    generators.modelOutput
-                );
-            })));
-
-        generators.delegateItemModel(fullBlock, getModelLocation(fullBlock, "_off"));
-        generators.delegateItemModel(ModRegistry.Items.WIRED_MODEM.get(), new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/wired_modem_off"));
-    }
-
-    private static ResourceLocation modemModel(BlockModelGenerators generators, ResourceLocation name, ResourceLocation texture) {
-        return MODEM.create(
-            name,
-            new TextureMapping()
-                .put(TextureSlot.FRONT, texture)
-                .put(TextureSlot.BACK, new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/modem_back")),
-            generators.modelOutput
-        );
-    }
-
-    private static void registerMonitor(BlockModelGenerators generators, MonitorBlock block) {
-        monitorModel(generators, block, "", 16, 4, 0, 32);
-        monitorModel(generators, block, "_d", 20, 7, 0, 36);
-        monitorModel(generators, block, "_l", 19, 4, 1, 33);
-        monitorModel(generators, block, "_ld", 31, 7, 1, 45);
-        monitorModel(generators, block, "_lr", 18, 4, 2, 34);
-        monitorModel(generators, block, "_lrd", 30, 7, 2, 46);
-        monitorModel(generators, block, "_lru", 24, 5, 2, 40);
-        monitorModel(generators, block, "_lrud", 27, 6, 2, 43);
-        monitorModel(generators, block, "_lu", 25, 5, 1, 39);
-        monitorModel(generators, block, "_lud", 28, 6, 1, 42);
-        monitorModel(generators, block, "_r", 17, 4, 3, 35);
-        monitorModel(generators, block, "_rd", 29, 7, 3, 47);
-        monitorModel(generators, block, "_ru", 23, 5, 3, 41);
-        monitorModel(generators, block, "_rud", 26, 6, 3, 44);
-        monitorModel(generators, block, "_u", 22, 5, 0, 38);
-        monitorModel(generators, block, "_ud", 21, 6, 0, 37);
-
-        generators.blockStateOutput.accept(MultiVariantGenerator.multiVariant(block)
-            .with(createHorizontalFacingDispatch())
-            .with(createVerticalFacingDispatch(MonitorBlock.ORIENTATION))
-            .with(createModelDispatch(MonitorBlock.STATE, edge -> getModelLocation(block, edge == MonitorEdgeState.NONE ? "" : "_" + edge.getSerializedName())))
-        );
-        generators.delegateItemModel(block, monitorModel(generators, block, "_item", 15, 4, 0, 32));
-    }
-
-    private static ResourceLocation monitorModel(BlockModelGenerators generators, MonitorBlock block, String corners, int front, int side, int top, int back) {
-        return MONITOR_BASE.create(
-            getModelLocation(block, corners),
-            new TextureMapping()
-                .put(TextureSlot.FRONT, getBlockTexture(block, "_" + front))
-                .put(TextureSlot.SIDE, getBlockTexture(block, "_" + side))
-                .put(TextureSlot.TOP, getBlockTexture(block, "_" + top))
-                .put(TextureSlot.BACK, getBlockTexture(block, "_" + back)),
-            generators.modelOutput
-        );
-    }
-
-    private static void registerCable(BlockModelGenerators generators) {
-        var generator = MultiPartGenerator.multiPart(ModRegistry.Blocks.CABLE.get());
-
-        // When a cable only has a neighbour in a single direction, we redirect the core to face that direction.
-        var coreFacing = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/cable_core_facing");
-        // Up/Down
-        generator.with(
-            Condition.or(
-                cableNoNeighbour(Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST).term(CableBlock.UP, true),
-                cableNoNeighbour(Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST).term(CableBlock.DOWN, true)
-            ),
-            Variant.variant().with(VariantProperties.MODEL, coreFacing).with(VariantProperties.X_ROT, VariantProperties.Rotation.R90)
-        );
-
-        // North/South and no neighbours
-        generator.with(
-            Condition.or(
-                cableNoNeighbour(Direction.UP, Direction.DOWN, Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST),
-                cableNoNeighbour(Direction.UP, Direction.DOWN, Direction.EAST, Direction.WEST).term(CableBlock.NORTH, true),
-                cableNoNeighbour(Direction.UP, Direction.DOWN, Direction.EAST, Direction.WEST).term(CableBlock.SOUTH, true)
-            ),
-            Variant.variant().with(VariantProperties.MODEL, coreFacing).with(VariantProperties.Y_ROT, VariantProperties.Rotation.R0)
-        );
-
-        // East/West
-        generator.with(
-            Condition.or(
-                cableNoNeighbour(Direction.NORTH, Direction.SOUTH, Direction.UP, Direction.DOWN).term(CableBlock.EAST, true),
-                cableNoNeighbour(Direction.NORTH, Direction.SOUTH, Direction.UP, Direction.DOWN).term(CableBlock.WEST, true)
-            ),
-            Variant.variant().with(VariantProperties.MODEL, coreFacing).with(VariantProperties.Y_ROT, VariantProperties.Rotation.R90)
-        );
-
-        // Find all other possibilities and emit a "solid" core which doesn't have a facing direction.
-        var core = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/cable_core_any");
-        List<Condition.TerminalCondition> rightAngles = new ArrayList<>();
-        for (var i = 0; i < DirectionUtil.FACINGS.length; i++) {
-            for (var j = i; j < DirectionUtil.FACINGS.length; j++) {
-                if (DirectionUtil.FACINGS[i].getAxis() == DirectionUtil.FACINGS[j].getAxis()) continue;
-
-                rightAngles.add(new Condition.TerminalCondition()
-                    .term(CableBlock.CABLE, true).term(CABLE_DIRECTIONS[i], true).term(CABLE_DIRECTIONS[j], true)
-                );
-            }
-        }
-        generator.with(Condition.or(rightAngles.toArray(new Condition[0])), Variant.variant().with(VariantProperties.MODEL, core));
-
-        // Then emit the actual cable arms
-        var arm = new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/cable_arm");
-        for (var direction : DirectionUtil.FACINGS) {
-            generator.with(
-                new Condition.TerminalCondition().term(CABLE_DIRECTIONS[direction.ordinal()], true),
-                Variant.variant()
-                    .with(VariantProperties.MODEL, arm)
-                    .with(VariantProperties.X_ROT, toXAngle(direction.getOpposite()))
-                    .with(VariantProperties.Y_ROT, toYAngle(direction.getOpposite()))
-            );
-        }
-
-        // And the modems!
-        for (var direction : DirectionUtil.FACINGS) {
-            for (var on : BOOLEANS) {
-                for (var peripheral : BOOLEANS) {
-                    var suffix = (on ? "_on" : "_off") + (peripheral ? "_peripheral" : "");
-                    generator.with(
-                        new Condition.TerminalCondition().term(CableBlock.MODEM, CableModemVariant.from(direction, on, peripheral)),
-                        Variant.variant()
-                            .with(VariantProperties.MODEL, new ResourceLocation(ComputerCraftAPI.MOD_ID, "block/wired_modem" + suffix))
-                            .with(VariantProperties.X_ROT, toXAngle(direction))
-                            .with(VariantProperties.Y_ROT, toYAngle(direction))
-                    );
-                }
-            }
-        }
-
-        generators.blockStateOutput.accept(generator);
-    }
-
-    private static final BooleanProperty[] CABLE_DIRECTIONS = { CableBlock.DOWN, CableBlock.UP, CableBlock.NORTH, CableBlock.SOUTH, CableBlock.WEST, CableBlock.EAST };
-    private static final boolean[] BOOLEANS = new boolean[]{ false, true };
-
-    private static Condition.TerminalCondition cableNoNeighbour(Direction... directions) {
-        var condition = new Condition.TerminalCondition().term(CableBlock.CABLE, true);
-        for (var direction : directions) condition.term(CABLE_DIRECTIONS[direction.ordinal()], false);
-        return condition;
-    }
-
-    private static void registerTurtleUpgrade(BlockModelGenerators generators, String name, String texture) {
-        TURTLE_UPGRADE_LEFT.create(
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, name + "_left"),
-            TextureMapping.defaultTexture(new ResourceLocation(ComputerCraftAPI.MOD_ID, texture)),
-            generators.modelOutput
-        );
-        TURTLE_UPGRADE_RIGHT.create(
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, name + "_right"),
-            TextureMapping.defaultTexture(new ResourceLocation(ComputerCraftAPI.MOD_ID, texture)),
-            generators.modelOutput
-        );
-    }
-
-    private static void registerTurtleModem(BlockModelGenerators generators, String name, String texture) {
-        registerTurtleUpgrade(generators, name + "_off", texture);
-        registerTurtleUpgrade(generators, name + "_on", texture + "_on");
-    }
-
-    private static VariantProperties.Rotation toXAngle(Direction direction) {
-        return switch (direction) {
-            default -> VariantProperties.Rotation.R0;
-            case UP -> VariantProperties.Rotation.R270;
-            case DOWN -> VariantProperties.Rotation.R90;
-        };
-    }
-
-    private static VariantProperties.Rotation toYAngle(Direction direction) {
-        return switch (direction) {
-            default -> VariantProperties.Rotation.R0;
-            case NORTH -> VariantProperties.Rotation.R0;
-            case SOUTH -> VariantProperties.Rotation.R180;
-            case EAST -> VariantProperties.Rotation.R90;
-            case WEST -> VariantProperties.Rotation.R270;
-        };
-    }
-
-    private static PropertyDispatch createHorizontalFacingDispatch() {
-        var dispatch = PropertyDispatch.property(BlockStateProperties.HORIZONTAL_FACING);
-        for (var direction : BlockStateProperties.HORIZONTAL_FACING.getPossibleValues()) {
-            dispatch.select(direction, Variant.variant().with(VariantProperties.Y_ROT, toYAngle(direction)));
-        }
-        return dispatch;
-    }
-
-    private static PropertyDispatch createVerticalFacingDispatch(Property<Direction> property) {
-        var dispatch = PropertyDispatch.property(property);
-        for (var direction : property.getPossibleValues()) {
-            dispatch.select(direction, Variant.variant().with(VariantProperties.X_ROT, toXAngle(direction)));
-        }
-        return dispatch;
-    }
-
-    private static PropertyDispatch createFacingDispatch() {
-        var dispatch = PropertyDispatch.property(BlockStateProperties.FACING);
-        for (var direction : BlockStateProperties.FACING.getPossibleValues()) {
-            dispatch.select(direction, Variant.variant()
-                .with(VariantProperties.Y_ROT, toYAngle(direction))
-                .with(VariantProperties.X_ROT, toXAngle(direction))
-            );
-        }
-        return dispatch;
-    }
-
-    private static <T extends Comparable<T>> PropertyDispatch createModelDispatch(Property<T> property, Function<T, ResourceLocation> makeModel) {
-        var variant = PropertyDispatch.property(property);
-        for (var value : property.getPossibleValues()) {
-            variant.select(value, Variant.variant().with(VariantProperties.MODEL, makeModel.apply(value)));
-        }
-        return variant;
-    }
-
-    private static <T extends Comparable<T>, U extends Comparable<U>> PropertyDispatch createModelDispatch(
-        Property<T> propertyT, Property<U> propertyU, BiFunction<T, U, ResourceLocation> makeModel
-    ) {
-        var variant = PropertyDispatch.properties(propertyT, propertyU);
-        for (var valueT : propertyT.getPossibleValues()) {
-            for (var valueU : propertyU.getPossibleValues()) {
-                variant.select(valueT, valueU, Variant.variant().with(VariantProperties.MODEL, makeModel.apply(valueT, valueU)));
-            }
-        }
-        return variant;
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/DataProviders.java

@@ -1,54 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import net.minecraft.data.DataProvider;
-import net.minecraft.data.PackOutput;
-import net.minecraft.data.loot.LootTableProvider.SubProviderEntry;
-import net.minecraft.data.models.BlockModelGenerators;
-import net.minecraft.data.models.ItemModelGenerators;
-import net.minecraft.data.tags.TagsProvider;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.level.block.Block;
-
-import java.util.List;
-import java.util.function.Consumer;
-
-/**
- * All data providers for ComputerCraft. We require a mod-loader abstraction {@link GeneratorSink} (instead of
- * {@link PackOutput})to handle the slight differences between how Forge and Fabric expose Minecraft's data providers.
- */
-public final class DataProviders {
-    private DataProviders() {
-    }
-
-    public static void add(GeneratorSink generator) {
-        var turtleUpgrades = generator.add(TurtleUpgradeProvider::new);
-        var pocketUpgrades = generator.add(PocketUpgradeProvider::new);
-        generator.add(out -> new RecipeProvider(out, turtleUpgrades, pocketUpgrades));
-
-        var blockTags = generator.blockTags(TagProvider::blockTags);
-        generator.itemTags(TagProvider::itemTags, blockTags);
-
-        generator.lootTable(LootTableProvider.getTables());
-
-        generator.models(BlockModelProvider::addBlockModels, ItemModelProvider::addItemModels);
-
-        generator.add(out -> new LanguageProvider(out, turtleUpgrades, pocketUpgrades));
-    }
-
-    interface GeneratorSink {
-        <T extends DataProvider> T add(DataProvider.Factory<T> factory);
-
-        void lootTable(List<SubProviderEntry> tables);
-
-        TagsProvider<Block> blockTags(Consumer<TagProvider.TagConsumer<Block>> tags);
-
-        TagsProvider<Item> itemTags(Consumer<TagProvider.ItemTagConsumer> tags, TagsProvider<Block> blocks);
-
-        void models(Consumer<BlockModelGenerators> blocks, Consumer<ItemModelGenerators> items);
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/ItemModelProvider.java

@@ -1,102 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.shared.ModRegistry;
-import net.minecraft.data.models.ItemModelGenerators;
-import net.minecraft.data.models.model.ModelTemplate;
-import net.minecraft.data.models.model.ModelTemplates;
-import net.minecraft.data.models.model.TextureMapping;
-import net.minecraft.data.models.model.TextureSlot;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
-
-import java.util.Optional;
-
-import static net.minecraft.data.models.model.ModelLocationUtils.getModelLocation;
-
-public final class ItemModelProvider {
-    private ItemModelProvider() {
-    }
-
-    public static void addItemModels(ItemModelGenerators generators) {
-        registerDisk(generators, ModRegistry.Items.DISK.get());
-        registerDisk(generators, ModRegistry.Items.TREASURE_DISK.get());
-
-        registerPocketComputer(generators, getModelLocation(ModRegistry.Items.POCKET_COMPUTER_NORMAL.get()), false);
-        registerPocketComputer(generators, getModelLocation(ModRegistry.Items.POCKET_COMPUTER_ADVANCED.get()), false);
-        registerPocketComputer(generators, new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/pocket_computer_colour"), true);
-
-        generators.generateFlatItem(ModRegistry.Items.PRINTED_BOOK.get(), ModelTemplates.FLAT_ITEM);
-        generators.generateFlatItem(ModRegistry.Items.PRINTED_PAGE.get(), ModelTemplates.FLAT_ITEM);
-        generators.generateFlatItem(ModRegistry.Items.PRINTED_PAGES.get(), ModelTemplates.FLAT_ITEM);
-    }
-
-    private static void registerPocketComputer(ItemModelGenerators generators, ResourceLocation id, boolean off) {
-        createFlatItem(generators, addSuffix(id, "_blinking"),
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/pocket_computer_blink"),
-            id,
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/pocket_computer_light")
-        );
-
-        createFlatItem(generators, addSuffix(id, "_on"),
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/pocket_computer_on"),
-            id,
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/pocket_computer_light")
-        );
-
-        // Don't emit the default/off state for advanced/normal pocket computers, as they have item overrides.
-        if (off) {
-            createFlatItem(generators, id,
-                new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/pocket_computer_frame"),
-                id
-            );
-        }
-    }
-
-    private static void registerDisk(ItemModelGenerators generators, Item item) {
-        createFlatItem(generators, item,
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/disk_frame"),
-            new ResourceLocation(ComputerCraftAPI.MOD_ID, "item/disk_colour")
-        );
-    }
-
-    private static void createFlatItem(ItemModelGenerators generators, Item item, ResourceLocation... ids) {
-        createFlatItem(generators, getModelLocation(item), ids);
-    }
-
-    /**
-     * Generate a flat item from an arbitrary number of layers.
-     *
-     * @param generators The current item generator helper.
-     * @param model      The model we're writing to.
-     * @param textures   The textures which make up this model.
-     * @see net.minecraft.client.renderer.block.model.ItemModelGenerator The parser for this file format.
-     */
-    private static void createFlatItem(ItemModelGenerators generators, ResourceLocation model, ResourceLocation... textures) {
-        if (textures.length > 5) throw new IndexOutOfBoundsException("Too many layers");
-        if (textures.length == 0) throw new IndexOutOfBoundsException("Must have at least one texture");
-        if (textures.length == 1) {
-            ModelTemplates.FLAT_ITEM.create(model, TextureMapping.layer0(textures[0]), generators.output);
-            return;
-        }
-
-        var slots = new TextureSlot[textures.length];
-        var mapping = new TextureMapping();
-        for (var i = 0; i < textures.length; i++) {
-            var slot = slots[i] = TextureSlot.create("layer" + i);
-            mapping.put(slot, textures[i]);
-        }
-
-        new ModelTemplate(Optional.of(new ResourceLocation("item/generated")), Optional.empty(), slots)
-            .create(model, mapping, generators.output);
-    }
-
-    private static ResourceLocation addSuffix(ResourceLocation location, String suffix) {
-        return new ResourceLocation(location.getNamespace(), location.getPath() + suffix);
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/LanguageProvider.java

@@ -1,323 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import com.electronwill.nightconfig.core.UnmodifiableConfig;
-import com.google.common.base.Splitter;
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.pocket.PocketUpgradeDataProvider;
-import dan200.computercraft.api.turtle.TurtleUpgradeDataProvider;
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.core.metrics.Metric;
-import dan200.computercraft.core.metrics.Metrics;
-import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.computer.metrics.basic.Aggregate;
-import dan200.computercraft.shared.computer.metrics.basic.AggregatedMetric;
-import dan200.computercraft.shared.config.ConfigSpec;
-import dan200.computercraft.shared.platform.RegistryWrappers;
-import net.minecraft.data.CachedOutput;
-import net.minecraft.data.DataProvider;
-import net.minecraft.data.PackOutput;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.level.block.Block;
-import net.minecraftforge.common.ForgeConfigSpec;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Stream;
-
-public final class LanguageProvider implements DataProvider {
-    private final PackOutput output;
-    private final TurtleUpgradeDataProvider turtleUpgrades;
-    private final PocketUpgradeDataProvider pocketUpgrades;
-
-    private final Map<String, String> translations = new HashMap<>();
-
-    public LanguageProvider(PackOutput output, TurtleUpgradeDataProvider turtleUpgrades, PocketUpgradeDataProvider pocketUpgrades) {
-        this.output = output;
-        this.turtleUpgrades = turtleUpgrades;
-        this.pocketUpgrades = pocketUpgrades;
-    }
-
-    @Override
-    public CompletableFuture<?> run(CachedOutput cachedOutput) {
-        addTranslations();
-        getExpectedKeys().forEach(x -> {
-            if (!translations.containsKey(x)) throw new IllegalStateException("No translation for " + x);
-        });
-
-        var json = new JsonObject();
-        for (var pair : translations.entrySet()) json.addProperty(pair.getKey(), pair.getValue());
-        return DataProvider.saveStable(cachedOutput, json, output.getOutputFolder().resolve("assets/" + ComputerCraftAPI.MOD_ID + "/lang/en_us.json"));
-    }
-
-    @Override
-    public String getName() {
-        return "Languages";
-    }
-
-    private void addTranslations() {
-        add("itemGroup.computercraft", "ComputerCraft");
-
-        // Blocks and items
-        add(ModRegistry.Items.COMPUTER_NORMAL.get(), "Computer");
-        add(ModRegistry.Items.COMPUTER_ADVANCED.get(), "Advanced Computer");
-        add(ModRegistry.Items.COMPUTER_COMMAND.get(), "Command Computer");
-
-        add(ModRegistry.Items.DISK_DRIVE.get(), "Disk Drive");
-        add(ModRegistry.Items.PRINTER.get(), "Printer");
-        add(ModRegistry.Items.SPEAKER.get(), "Speaker");
-        add(ModRegistry.Items.MONITOR_NORMAL.get(), "Monitor");
-        add(ModRegistry.Items.MONITOR_ADVANCED.get(), "Advanced Monitor");
-        add(ModRegistry.Items.WIRELESS_MODEM_NORMAL.get(), "Wireless Modem");
-        add(ModRegistry.Items.WIRELESS_MODEM_ADVANCED.get(), "Ender Modem");
-        add(ModRegistry.Items.WIRED_MODEM.get(), "Wired Modem");
-        add(ModRegistry.Items.CABLE.get(), "Networking Cable");
-        add(ModRegistry.Items.WIRED_MODEM_FULL.get(), "Wired Modem");
-
-        add(ModRegistry.Items.TURTLE_NORMAL.get(), "Turtle");
-        add(ModRegistry.Blocks.TURTLE_NORMAL.get().getDescriptionId() + ".upgraded", "%s Turtle");
-        add(ModRegistry.Blocks.TURTLE_NORMAL.get().getDescriptionId() + ".upgraded_twice", "%s %s Turtle");
-
-        add(ModRegistry.Items.TURTLE_ADVANCED.get(), "Advanced Turtle");
-        add(ModRegistry.Blocks.TURTLE_ADVANCED.get().getDescriptionId() + ".upgraded", "Advanced %s Turtle");
-        add(ModRegistry.Blocks.TURTLE_ADVANCED.get().getDescriptionId() + ".upgraded_twice", "Advanced %s %s Turtle");
-
-        add(ModRegistry.Items.DISK.get(), "Floppy Disk");
-        add(ModRegistry.Items.TREASURE_DISK.get(), "Floppy Disk");
-        add(ModRegistry.Items.PRINTED_PAGE.get(), "Printed Page");
-        add(ModRegistry.Items.PRINTED_PAGES.get(), "Printed Pages");
-        add(ModRegistry.Items.PRINTED_BOOK.get(), "Printed Book");
-
-        add(ModRegistry.Items.POCKET_COMPUTER_NORMAL.get(), "Pocket Computer");
-        add(ModRegistry.Items.POCKET_COMPUTER_NORMAL.get().getDescriptionId() + ".upgraded", "%s Pocket Computer");
-        add(ModRegistry.Items.POCKET_COMPUTER_ADVANCED.get(), "Advanced Pocket Computer");
-        add(ModRegistry.Items.POCKET_COMPUTER_ADVANCED.get().getDescriptionId() + ".upgraded", "Advanced %s Pocket Computer");
-
-        // Turtle/pocket upgrades
-        add("upgrade.minecraft.diamond_sword.adjective", "Melee");
-        add("upgrade.minecraft.diamond_shovel.adjective", "Digging");
-        add("upgrade.minecraft.diamond_pickaxe.adjective", "Mining");
-        add("upgrade.minecraft.diamond_axe.adjective", "Felling");
-        add("upgrade.minecraft.diamond_hoe.adjective", "Farming");
-        add("upgrade.minecraft.crafting_table.adjective", "Crafty");
-        add("upgrade.computercraft.wireless_modem_normal.adjective", "Wireless");
-        add("upgrade.computercraft.wireless_modem_advanced.adjective", "Ender");
-        add("upgrade.computercraft.speaker.adjective", "Noisy");
-
-        add("chat.computercraft.wired_modem.peripheral_connected", "Peripheral \"%s\" connected to network");
-        add("chat.computercraft.wired_modem.peripheral_disconnected", "Peripheral \"%s\" disconnected from network");
-
-        // Commands
-        add("commands.computercraft.synopsis", "Various commands for controlling computers.");
-        add("commands.computercraft.desc", "The /computercraft command provides various debugging and administrator tools for controlling and interacting with computers.");
-        add("commands.computercraft.help.synopsis", "Provide help for a specific command");
-        add("commands.computercraft.help.desc", "Displays this help message");
-        add("commands.computercraft.help.no_children", "%s has no sub-commands");
-        add("commands.computercraft.help.no_command", "No such command '%s'");
-        add("commands.computercraft.dump.synopsis", "Display the status of computers.");
-        add("commands.computercraft.dump.desc", "Display the status of all computers or specific information about one computer. You can specify the computer's instance id (e.g. 123), computer id (e.g #123) or label (e.g. \"@My Computer\").");
-        add("commands.computercraft.dump.action", "View more info about this computer");
-        add("commands.computercraft.dump.open_path", "View this computer's files");
-        add("commands.computercraft.shutdown.synopsis", "Shutdown computers remotely.");
-        add("commands.computercraft.shutdown.desc", "Shutdown the listed computers or all if none are specified. You can specify the computer's instance id (e.g. 123), computer id (e.g #123) or label (e.g. \"@My Computer\").");
-        add("commands.computercraft.shutdown.done", "Shutdown %s/%s computers");
-        add("commands.computercraft.turn_on.synopsis", "Turn computers on remotely.");
-        add("commands.computercraft.turn_on.desc", "Turn on the listed computers. You can specify the computer's instance id (e.g. 123), computer id (e.g #123) or label (e.g. \"@My Computer\").");
-        add("commands.computercraft.turn_on.done", "Turned on %s/%s computers");
-        add("commands.computercraft.tp.synopsis", "Teleport to a specific computer.");
-        add("commands.computercraft.tp.desc", "Teleport to the location of a computer. You can either specify the computer's instance id (e.g. 123) or computer id (e.g #123).");
-        add("commands.computercraft.tp.action", "Teleport to this computer");
-        add("commands.computercraft.tp.not_player", "Cannot open terminal for non-player");
-        add("commands.computercraft.tp.not_there", "Cannot locate computer in the world");
-        add("commands.computercraft.view.synopsis", "View the terminal of a computer.");
-        add("commands.computercraft.view.desc", "Open the terminal of a computer, allowing remote control of a computer. This does not provide access to turtle's inventories. You can either specify the computer's instance id (e.g. 123) or computer id (e.g #123).");
-        add("commands.computercraft.view.action", "View this computer");
-        add("commands.computercraft.view.not_player", "Cannot open terminal for non-player");
-        add("commands.computercraft.track.synopsis", "Track execution times for computers.");
-        add("commands.computercraft.track.desc", "Track how long computers execute for, as well as how many events they handle. This presents information in a similar way to /forge track and can be useful for diagnosing lag.");
-        add("commands.computercraft.track.start.synopsis", "Start tracking all computers");
-        add("commands.computercraft.track.start.desc", "Start tracking all computers' execution times and event counts. This will discard the results of previous runs.");
-        add("commands.computercraft.track.start.stop", "Run %s to stop tracking and view the results");
-        add("commands.computercraft.track.stop.synopsis", "Stop tracking all computers");
-        add("commands.computercraft.track.stop.desc", "Stop tracking all computers' events and execution times");
-        add("commands.computercraft.track.stop.action", "Click to stop tracking");
-        add("commands.computercraft.track.stop.not_enabled", "Not currently tracking computers");
-        add("commands.computercraft.track.dump.synopsis", "Dump the latest track results");
-        add("commands.computercraft.track.dump.desc", "Dump the latest results of computer tracking.");
-        add("commands.computercraft.track.dump.no_timings", "No timings available");
-        add("commands.computercraft.track.dump.computer", "Computer");
-        add("commands.computercraft.reload.synopsis", "Reload the ComputerCraft config file");
-        add("commands.computercraft.reload.desc", "Reload the ComputerCraft config file");
-        add("commands.computercraft.reload.done", "Reloaded config");
-        add("commands.computercraft.queue.synopsis", "Send a computer_command event to a command computer");
-        add("commands.computercraft.queue.desc", "Send a computer_command event to a command computer, passing through the additional arguments. This is mostly designed for map makers, acting as a more computer-friendly version of /trigger. Any player can run the command, which would most likely be done through a text component's click event.");
-
-        add("commands.computercraft.generic.no_position", "<no pos>");
-        add("commands.computercraft.generic.position", "%s, %s, %s");
-        add("commands.computercraft.generic.yes", "Y");
-        add("commands.computercraft.generic.no", "N");
-        add("commands.computercraft.generic.exception", "Unhandled exception (%s)");
-        add("commands.computercraft.generic.additional_rows", "%d additional rows…");
-
-        add("argument.computercraft.computer.no_matching", "No computers matching '%s'");
-        add("argument.computercraft.computer.many_matching", "Multiple computers matching '%s' (instances %s)");
-        add("argument.computercraft.tracking_field.no_field", "Unknown field '%s'");
-        add("argument.computercraft.argument_expected", "Argument expected");
-
-        // Metrics
-        add(Metrics.COMPUTER_TASKS, "Tasks");
-        add(Metrics.SERVER_TASKS, "Server tasks");
-        add(Metrics.PERIPHERAL_OPS, "Peripheral calls");
-        add(Metrics.FS_OPS, "Filesystem operations");
-        add(Metrics.HTTP_REQUESTS, "HTTP requests");
-        add(Metrics.HTTP_UPLOAD, "HTTP upload");
-        add(Metrics.HTTP_DOWNLOAD, "HTTP download");
-        add(Metrics.WEBSOCKET_INCOMING, "Websocket incoming");
-        add(Metrics.WEBSOCKET_OUTGOING, "Websocket outgoing");
-        add(Metrics.COROUTINES_CREATED, "Coroutines created");
-        add(Metrics.COROUTINES_DISPOSED, "Coroutines disposed");
-        add(Metrics.TURTLE_OPS, "Turtle operations");
-
-        add(AggregatedMetric.TRANSLATION_PREFIX + Aggregate.MAX.id(), "%s (max)");
-        add(AggregatedMetric.TRANSLATION_PREFIX + Aggregate.AVG.id(), "%s (avg)");
-        add(AggregatedMetric.TRANSLATION_PREFIX + Aggregate.COUNT.id(), "%s (count)");
-
-        // Additional UI elements
-        add("gui.computercraft.terminal", "Computer terminal");
-        add("gui.computercraft.tooltip.copy", "Copy to clipboard");
-        add("gui.computercraft.tooltip.computer_id", "Computer ID: %s");
-        add("gui.computercraft.tooltip.disk_id", "Disk ID: %s");
-        add("gui.computercraft.tooltip.turn_on", "Turn this computer on");
-        add("gui.computercraft.tooltip.turn_off", "Turn this computer off");
-        add("gui.computercraft.tooltip.turn_off.key", "Hold Ctrl+S");
-        add("gui.computercraft.tooltip.terminate", "Stop the currently running code");
-        add("gui.computercraft.tooltip.terminate.key", "Hold Ctrl+T");
-        add("gui.computercraft.upload.failed", "Upload Failed");
-        add("gui.computercraft.upload.failed.computer_off", "You must turn the computer on before uploading files.");
-        add("gui.computercraft.upload.failed.too_much", "Your files are too large to be uploaded.");
-        add("gui.computercraft.upload.failed.name_too_long", "File names are too long to be uploaded.");
-        add("gui.computercraft.upload.failed.too_many_files", "Cannot upload this many files.");
-        add("gui.computercraft.upload.failed.generic", "Uploading files failed (%s)");
-        add("gui.computercraft.upload.failed.corrupted", "Files corrupted when uploading. Please try again.");
-        add("gui.computercraft.upload.no_response", "Transferring Files");
-        add("gui.computercraft.upload.no_response.msg", "Your computer has not used your transferred files. You may need to run the %s program and try again.");
-        add("gui.computercraft.pocket_computer_overlay", "Pocket computer open. Press ESC to close.");
-
-        // Config options
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.computerSpaceLimit, "Computer space limit (bytes)");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.floppySpaceLimit, "Floppy Disk space limit (bytes)");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.maximumFilesOpen, "Maximum files open per computer");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.disableLua51Features, "Disable Lua 5.1 features");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.defaultComputerSettings, "Default Computer settings");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.logComputerErrors, "Log computer errors");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.commandRequireCreative, "Command computers require creative");
-
-        addConfigGroup(ConfigSpec.serverSpec, "execution", "Execution");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.computerThreads, "Computer threads");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.maxMainGlobalTime, "Server tick global time limit");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.maxMainComputerTime, "Server tick computer time limit");
-
-        addConfigGroup(ConfigSpec.serverSpec, "http", "HTTP");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.httpEnabled, "Enable the HTTP API");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.httpWebsocketEnabled, "Enable websockets");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.httpRules, "Allow/deny rules");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.httpMaxRequests, "Maximum concurrent requests");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.httpMaxWebsockets, "Maximum concurrent websockets");
-        addConfigGroup(ConfigSpec.serverSpec, "http.bandwidth", "Bandwidth");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.httpDownloadBandwidth, "Global download limit");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.httpUploadBandwidth, "Global upload limit");
-
-        addConfigGroup(ConfigSpec.serverSpec, "peripheral", "Peripherals");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.commandBlockEnabled, "Enable command block peripheral");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.modemRange, "Modem range (default)");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.modemHighAltitudeRange, "Modem range (high-altitude)");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.modemRangeDuringStorm, "Modem range (bad weather)");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.modemHighAltitudeRangeDuringStorm, "Modem range (high-altitude, bad weather)");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.maxNotesPerTick, "Maximum notes that a computer can play at once");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.monitorBandwidth, "Monitor bandwidth");
-
-        addConfigGroup(ConfigSpec.serverSpec, "turtle", "Turtles");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.turtlesNeedFuel, "Enable fuel");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.turtleFuelLimit, "Turtle fuel limit");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.advancedTurtleFuelLimit, "Advanced Turtle fuel limit");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.turtlesCanPush, "Turtles can push entities");
-
-        addConfigGroup(ConfigSpec.serverSpec, "term_sizes", "Terminal sizes");
-        addConfigGroup(ConfigSpec.serverSpec, "term_sizes.computer", "Computer");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.computerTermWidth, "Terminal width");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.computerTermHeight, "Terminal height");
-        addConfigGroup(ConfigSpec.serverSpec, "term_sizes.pocket_computer", "Pocket Computer");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.pocketTermWidth, "Terminal width");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.pocketTermHeight, "Terminal height");
-        addConfigGroup(ConfigSpec.serverSpec, "term_sizes.monitor", "Monitor");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.monitorWidth, "Max monitor width");
-        addConfigValue(ConfigSpec.serverSpec, ConfigSpec.monitorHeight, "Max monitor height");
-
-        addConfigValue(ConfigSpec.clientSpec, ConfigSpec.monitorRenderer, "Monitor renderer");
-        addConfigValue(ConfigSpec.clientSpec, ConfigSpec.monitorDistance, "Monitor distance");
-        addConfigValue(ConfigSpec.clientSpec, ConfigSpec.uploadNagDelay, "Upload nag delay");
-    }
-
-    private Stream<String> getExpectedKeys() {
-        return Stream.of(
-            RegistryWrappers.BLOCKS.stream()
-                .filter(x -> RegistryWrappers.BLOCKS.getKey(x).getNamespace().equals(ComputerCraftAPI.MOD_ID))
-                .map(Block::getDescriptionId),
-            RegistryWrappers.ITEMS.stream()
-                .filter(x -> RegistryWrappers.ITEMS.getKey(x).getNamespace().equals(ComputerCraftAPI.MOD_ID))
-                .map(Item::getDescriptionId),
-            turtleUpgrades.getGeneratedUpgrades().stream().map(UpgradeBase::getUnlocalisedAdjective),
-            pocketUpgrades.getGeneratedUpgrades().stream().map(UpgradeBase::getUnlocalisedAdjective),
-            Metric.metrics().values().stream().map(x -> AggregatedMetric.TRANSLATION_PREFIX + x.name() + ".name"),
-            getConfigKeys(ConfigSpec.serverSpec),
-            getConfigKeys(ConfigSpec.clientSpec)
-        ).flatMap(x -> x);
-    }
-
-    private Stream<String> getConfigKeys(UnmodifiableConfig spec) {
-        return spec.entrySet().stream().flatMap(x -> {
-            if (x.getValue() instanceof ForgeConfigSpec.ValueSpec valueSpec) {
-                return Stream.of(valueSpec.getTranslationKey());
-            } else if (x.getValue() instanceof UnmodifiableConfig config) {
-                return getConfigKeys(config);
-            } else {
-                return Stream.empty();
-            }
-        });
-    }
-
-    private void add(String id, String text) {
-        Objects.requireNonNull(id, "id cannot be null");
-        Objects.requireNonNull(text, "text cannot be null");
-
-        if (translations.containsKey(id)) throw new IllegalArgumentException("Duplicate translation " + id);
-        translations.put(id, text);
-    }
-
-    private void add(Item item, String text) {
-        add(item.getDescriptionId(), text);
-    }
-
-    private void add(Metric metric, String text) {
-        add(AggregatedMetric.TRANSLATION_PREFIX + metric.name() + ".name", text);
-    }
-
-    private void addConfigGroup(ForgeConfigSpec spec, String path, String text) {
-        var pathList = Splitter.on('.').splitToList(path);
-        add(spec.getLevelTranslationKey(pathList), text);
-        add(spec.getLevelTranslationKey(pathList) + ".tooltip", spec.getLevelComment(pathList));
-    }
-
-    private void addConfigValue(ForgeConfigSpec spec, ForgeConfigSpec.ConfigValue<?> value, String text) {
-        ForgeConfigSpec.ValueSpec valueSpec = spec.getSpec().get(value.getPath());
-        add(valueSpec.getTranslationKey(), text);
-        add(valueSpec.getTranslationKey() + ".tooltip", valueSpec.getComment());
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/LootTableProvider.java

@@ -1,125 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.shared.CommonHooks;
-import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.data.BlockNamedEntityLootCondition;
-import dan200.computercraft.shared.data.HasComputerIdLootCondition;
-import dan200.computercraft.shared.data.PlayerCreativeLootCondition;
-import dan200.computercraft.shared.peripheral.modem.wired.CableBlock;
-import dan200.computercraft.shared.peripheral.modem.wired.CableModemVariant;
-import net.minecraft.advancements.critereon.StatePropertiesPredicate;
-import net.minecraft.data.loot.LootTableProvider.SubProviderEntry;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.storage.loot.LootPool;
-import net.minecraft.world.level.storage.loot.LootTable;
-import net.minecraft.world.level.storage.loot.entries.DynamicLoot;
-import net.minecraft.world.level.storage.loot.entries.LootItem;
-import net.minecraft.world.level.storage.loot.entries.LootPoolEntryContainer;
-import net.minecraft.world.level.storage.loot.functions.CopyNameFunction;
-import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets;
-import net.minecraft.world.level.storage.loot.predicates.AlternativeLootItemCondition;
-import net.minecraft.world.level.storage.loot.predicates.ExplosionCondition;
-import net.minecraft.world.level.storage.loot.predicates.LootItemBlockStatePropertyCondition;
-import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
-import net.minecraft.world.level.storage.loot.providers.number.ConstantValue;
-
-import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.Supplier;
-
-class LootTableProvider {
-    public static List<SubProviderEntry> getTables() {
-        return List.of(
-            new SubProviderEntry(() -> LootTableProvider::registerBlocks, LootContextParamSets.BLOCK),
-            new SubProviderEntry(() -> LootTableProvider::registerGeneric, LootContextParamSets.ALL_PARAMS)
-        );
-    }
-
-    private static void registerBlocks(BiConsumer<ResourceLocation, LootTable.Builder> add) {
-        namedBlockDrop(add, ModRegistry.Blocks.DISK_DRIVE);
-        selfDrop(add, ModRegistry.Blocks.MONITOR_NORMAL);
-        selfDrop(add, ModRegistry.Blocks.MONITOR_ADVANCED);
-        namedBlockDrop(add, ModRegistry.Blocks.PRINTER);
-        selfDrop(add, ModRegistry.Blocks.SPEAKER);
-        selfDrop(add, ModRegistry.Blocks.WIRED_MODEM_FULL);
-        selfDrop(add, ModRegistry.Blocks.WIRELESS_MODEM_NORMAL);
-        selfDrop(add, ModRegistry.Blocks.WIRELESS_MODEM_ADVANCED);
-
-        computerDrop(add, ModRegistry.Blocks.COMPUTER_NORMAL);
-        computerDrop(add, ModRegistry.Blocks.COMPUTER_ADVANCED);
-        computerDrop(add, ModRegistry.Blocks.COMPUTER_COMMAND);
-        computerDrop(add, ModRegistry.Blocks.TURTLE_NORMAL);
-        computerDrop(add, ModRegistry.Blocks.TURTLE_ADVANCED);
-
-        add.accept(ModRegistry.Blocks.CABLE.get().getLootTable(), LootTable
-            .lootTable()
-            .withPool(LootPool.lootPool()
-                .setRolls(ConstantValue.exactly(1))
-                .add(LootItem.lootTableItem(ModRegistry.Items.CABLE.get()))
-                .when(ExplosionCondition.survivesExplosion())
-                .when(LootItemBlockStatePropertyCondition.hasBlockStateProperties(ModRegistry.Blocks.CABLE.get())
-                    .setProperties(StatePropertiesPredicate.Builder.properties().hasProperty(CableBlock.CABLE, true))
-                )
-            )
-            .withPool(LootPool.lootPool()
-                .setRolls(ConstantValue.exactly(1))
-                .add(LootItem.lootTableItem(ModRegistry.Items.WIRED_MODEM.get()))
-                .when(ExplosionCondition.survivesExplosion())
-                .when(LootItemBlockStatePropertyCondition.hasBlockStateProperties(ModRegistry.Blocks.CABLE.get())
-                    .setProperties(StatePropertiesPredicate.Builder.properties().hasProperty(CableBlock.MODEM, CableModemVariant.None))
-                    .invert()
-                )
-            ));
-    }
-
-    private static void registerGeneric(BiConsumer<ResourceLocation, LootTable.Builder> add) {
-        add.accept(CommonHooks.LOOT_TREASURE_DISK, LootTable.lootTable());
-    }
-
-    private static void selfDrop(BiConsumer<ResourceLocation, LootTable.Builder> add, Supplier<? extends Block> wrapper) {
-        blockDrop(add, wrapper, LootItem.lootTableItem(wrapper.get()), ExplosionCondition.survivesExplosion());
-    }
-
-    private static void namedBlockDrop(BiConsumer<ResourceLocation, LootTable.Builder> add, Supplier<? extends Block> wrapper) {
-        blockDrop(
-            add, wrapper,
-            LootItem.lootTableItem(wrapper.get()).apply(CopyNameFunction.copyName(CopyNameFunction.NameSource.BLOCK_ENTITY)),
-            ExplosionCondition.survivesExplosion()
-        );
-    }
-
-    private static void computerDrop(BiConsumer<ResourceLocation, LootTable.Builder> add, Supplier<? extends Block> block) {
-        blockDrop(
-            add, block,
-            DynamicLoot.dynamicEntry(new ResourceLocation(ComputerCraftAPI.MOD_ID, "computer")),
-            AlternativeLootItemCondition.alternative(
-                BlockNamedEntityLootCondition.BUILDER,
-                HasComputerIdLootCondition.BUILDER,
-                PlayerCreativeLootCondition.BUILDER.invert()
-            )
-        );
-    }
-
-    private static void blockDrop(
-        BiConsumer<ResourceLocation, LootTable.Builder> add, Supplier<? extends Block> wrapper,
-        LootPoolEntryContainer.Builder<?> drop,
-        LootItemCondition.Builder condition
-    ) {
-        var block = wrapper.get();
-        add.accept(block.getLootTable(), LootTable
-            .lootTable()
-            .withPool(LootPool.lootPool()
-                .setRolls(ConstantValue.exactly(1))
-                .add(drop)
-                .when(condition)
-            )
-        );
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/ModelProvider.java

@@ -1,101 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import com.google.gson.JsonElement;
-import dan200.computercraft.shared.platform.RegistryWrappers;
-import net.minecraft.Util;
-import net.minecraft.data.CachedOutput;
-import net.minecraft.data.DataProvider;
-import net.minecraft.data.PackOutput;
-import net.minecraft.data.models.BlockModelGenerators;
-import net.minecraft.data.models.ItemModelGenerators;
-import net.minecraft.data.models.blockstates.BlockStateGenerator;
-import net.minecraft.data.models.model.DelegatedModel;
-import net.minecraft.data.models.model.ModelLocationUtils;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.level.block.Block;
-
-import java.nio.file.Path;
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-/**
- * A copy of {@link net.minecraft.data.models.ModelProvider} which accepts a custom generator.
- * <p>
- * Please don't sue me Mojang. Or at least make these changes to vanilla before doing so!
- */
-public class ModelProvider implements DataProvider {
-    private final PackOutput.PathProvider blockStatePath;
-    private final PackOutput.PathProvider modelPath;
-
-    private final Consumer<BlockModelGenerators> blocks;
-    private final Consumer<ItemModelGenerators> items;
-
-    public ModelProvider(PackOutput output, Consumer<BlockModelGenerators> blocks, Consumer<ItemModelGenerators> items) {
-        blockStatePath = output.createPathProvider(PackOutput.Target.RESOURCE_PACK, "blockstates");
-        modelPath = output.createPathProvider(PackOutput.Target.RESOURCE_PACK, "models");
-
-        this.blocks = blocks;
-        this.items = items;
-    }
-
-    @Override
-    public CompletableFuture<?> run(CachedOutput output) {
-        Map<Block, BlockStateGenerator> blockStates = new HashMap<>();
-        Consumer<BlockStateGenerator> addBlockState = generator -> {
-            var block = generator.getBlock();
-            if (blockStates.containsKey(block)) {
-                throw new IllegalStateException("Duplicate blockstate definition for " + block);
-            }
-            blockStates.put(block, generator);
-        };
-
-        Map<ResourceLocation, Supplier<JsonElement>> models = new HashMap<>();
-        BiConsumer<ResourceLocation, Supplier<JsonElement>> addModel = (id, contents) -> {
-            if (models.containsKey(id)) throw new IllegalStateException("Duplicate model definition for " + id);
-            models.put(id, contents);
-        };
-        Set<Item> explicitItems = new HashSet<>();
-        blocks.accept(new BlockModelGenerators(addBlockState, addModel, explicitItems::add));
-        items.accept(new ItemModelGenerators(addModel));
-
-        for (var block : RegistryWrappers.BLOCKS) {
-            if (!blockStates.containsKey(block)) continue;
-
-            var item = Item.BY_BLOCK.get(block);
-            if (item == null || explicitItems.contains(item)) continue;
-
-            var model = ModelLocationUtils.getModelLocation(item);
-            if (!models.containsKey(model)) {
-                models.put(model, new DelegatedModel(ModelLocationUtils.getModelLocation(block)));
-            }
-        }
-
-        List<CompletableFuture<?>> futures = new ArrayList<>();
-        saveCollection(output, futures, blockStates, x -> blockStatePath.json(RegistryWrappers.BLOCKS.getKey(x)));
-        saveCollection(output, futures, models, modelPath::json);
-        return Util.sequenceFailFast(futures);
-    }
-
-    private <T> void saveCollection(CachedOutput output, List<CompletableFuture<?>> futures, Map<T, ? extends Supplier<JsonElement>> items, Function<T, Path> getLocation) {
-        for (Map.Entry<T, ? extends Supplier<JsonElement>> entry : items.entrySet()) {
-            var path = getLocation.apply(entry.getKey());
-
-            futures.add(DataProvider.saveStable(output, entry.getValue().get(), path));
-        }
-    }
-
-    @Override
-    public String getName() {
-        return "Block State Definitions";
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/PocketUpgradeProvider.java

@@ -1,34 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.pocket.PocketUpgradeDataProvider;
-import dan200.computercraft.api.pocket.PocketUpgradeSerialiser;
-import net.minecraft.data.PackOutput;
-import net.minecraft.resources.ResourceLocation;
-
-import java.util.function.Consumer;
-
-import static dan200.computercraft.shared.ModRegistry.Items;
-import static dan200.computercraft.shared.ModRegistry.PocketUpgradeSerialisers;
-
-class PocketUpgradeProvider extends PocketUpgradeDataProvider {
-    PocketUpgradeProvider(PackOutput output) {
-        super(output);
-    }
-
-    @Override
-    protected void addUpgrades(Consumer<Upgrade<PocketUpgradeSerialiser<?>>> addUpgrade) {
-        addUpgrade.accept(simpleWithCustomItem(id("speaker"), PocketUpgradeSerialisers.SPEAKER.get(), Items.SPEAKER.get()));
-        simpleWithCustomItem(id("wireless_modem_normal"), PocketUpgradeSerialisers.WIRELESS_MODEM_NORMAL.get(), Items.WIRELESS_MODEM_NORMAL.get()).add(addUpgrade);
-        simpleWithCustomItem(id("wireless_modem_advanced"), PocketUpgradeSerialisers.WIRELESS_MODEM_ADVANCED.get(), Items.WIRELESS_MODEM_ADVANCED.get()).add(addUpgrade);
-    }
-
-    private static ResourceLocation id(String id) {
-        return new ResourceLocation(ComputerCraftAPI.MOD_ID, id);
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/PrettyJsonWriter.java

@@ -1,340 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonSyntaxException;
-import com.google.gson.stream.JsonWriter;
-import net.minecraft.data.DataProvider;
-import net.minecraft.util.GsonHelper;
-
-import javax.annotation.Nullable;
-import java.io.*;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Deque;
-import java.util.List;
-
-/**
- * Alternative version of {@link JsonWriter} which attempts to lay out the JSON in a more compact format.
- * <p>
- * Yes, this is at least a little deranged.
- */
-public class PrettyJsonWriter extends JsonWriter {
-    public static final boolean ENABLED = System.getProperty("cct.pretty-json") != null;
-    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
-
-    private static final int MAX_WIDTH = 120;
-
-    private final Writer out;
-
-    /**
-     * A stack of objects. This is either a {@link String} (in which case we've received an object key but no value)
-     * or a {@link DocList} (which either represents an array or object).
-     */
-    private final Deque<Object> stack = new ArrayDeque<>();
-
-    public PrettyJsonWriter(Writer out) {
-        super(out);
-        this.out = out;
-    }
-
-    /**
-     * Create a JSON writer. This will either be a pretty or normal version, depending on whether the global flag is
-     * set.
-     *
-     * @param out The writer to emit to.
-     * @return The constructed JSON writer.
-     */
-    public static JsonWriter createWriter(Writer out) {
-        return ENABLED ? new PrettyJsonWriter(out) : new JsonWriter(out);
-    }
-
-    /**
-     * Reformat a JSON string with our pretty printer.
-     *
-     * @param contents The string to reformat.
-     * @return The reformatted string.
-     */
-    public static byte[] reformat(byte[] contents) {
-        if (!ENABLED) return contents;
-
-        JsonElement object;
-        try (var reader = new InputStreamReader(new ByteArrayInputStream(contents), StandardCharsets.UTF_8)) {
-            object = GSON.fromJson(reader, JsonElement.class);
-        } catch (IOException e) {
-            throw new UncheckedIOException(e);
-        } catch (JsonSyntaxException e) {
-            return contents;
-        }
-
-        var out = new ByteArrayOutputStream();
-        try (var writer = new PrettyJsonWriter(new OutputStreamWriter(out, StandardCharsets.UTF_8))) {
-            GsonHelper.writeValue(writer, object, DataProvider.KEY_COMPARATOR);
-        } catch (IOException e) {
-            throw new UncheckedIOException(e);
-        }
-        out.write('\n');
-
-        return out.toByteArray();
-    }
-
-    private void pushValue(Object object) throws IOException {
-        // We've popped our top object, just write a value.
-        if (stack.isEmpty()) {
-            write(out, object, MAX_WIDTH, 0);
-            return;
-        }
-
-        // Otherwise we either need to push to our list or finish a record pair.
-        var head = stack.getLast();
-        if (head instanceof DocList) {
-            ((DocList) head).add(object);
-        } else {
-            stack.removeLast();
-            ((DocList) stack.getLast()).add(new Pair((String) head, object));
-        }
-    }
-
-    @Override
-    public JsonWriter beginArray() {
-        stack.add(new DocList("[", "]"));
-        return this;
-    }
-
-    @Override
-    public JsonWriter endArray() throws IOException {
-        var list = (DocList) stack.removeLast();
-        pushValue(list);
-        return this;
-    }
-
-    @Override
-    public JsonWriter beginObject() {
-        stack.add(new DocList("{", "}"));
-        return this;
-    }
-
-    @Override
-    public JsonWriter endObject() throws IOException {
-        return endArray();
-    }
-
-    @Override
-    public JsonWriter name(String name) throws IOException {
-        stack.add(escapeString(name));
-        return this;
-    }
-
-    @Override
-    public JsonWriter jsonValue(String value) throws IOException {
-        pushValue(value);
-        return this;
-    }
-
-    @Override
-    public JsonWriter value(@Nullable String value) throws IOException {
-        return value == null ? nullValue() : jsonValue(escapeString(value));
-    }
-
-    @Override
-    public JsonWriter nullValue() throws IOException {
-        if (!getSerializeNulls() && stack.peekLast() instanceof String) {
-            stack.removeLast();
-            return this;
-        }
-
-        return jsonValue("null");
-    }
-
-    @Override
-    public JsonWriter value(boolean value) throws IOException {
-        return jsonValue(Boolean.toString(value));
-    }
-
-    @Override
-    public JsonWriter value(@Nullable Boolean value) throws IOException {
-        return value == null ? nullValue() : jsonValue(Boolean.toString(value));
-    }
-
-    @Override
-    public JsonWriter value(double value) throws IOException {
-        return jsonValue(Double.toString(value));
-    }
-
-    @Override
-    public JsonWriter value(long value) throws IOException {
-        return jsonValue(Long.toString(value));
-    }
-
-    @Override
-    public JsonWriter value(@Nullable Number value) throws IOException {
-        return value == null ? nullValue() : jsonValue(value.toString());
-    }
-
-    @Override
-    public void close() throws IOException {
-        if (!stack.isEmpty()) throw new IllegalArgumentException("Object is remaining on the stack");
-        out.close();
-    }
-
-    /**
-     * A key/value pair inside a JSON object.
-     *
-     * @param key   The escaped object key.
-     * @param value The object value.
-     */
-    private record Pair(String key, Object value) {
-        int width() {
-            return key.length() + 2 + PrettyJsonWriter.width(value);
-        }
-
-        int write(Writer out, int space, int indent) throws IOException {
-            out.write(key);
-            out.write(": ");
-            return PrettyJsonWriter.write(out, value, space - key.length() - 2, indent);
-        }
-    }
-
-    /**
-     * A list of terms inside a JSON document. Either an array or a JSON object.
-     */
-    private static class DocList {
-        final String prefix;
-        final String suffix;
-        final List<Object> contents = new ArrayList<>();
-        int width;
-
-        DocList(String prefix, String suffix) {
-            this.prefix = prefix;
-            this.suffix = suffix;
-            width = prefix.length() + suffix.length();
-        }
-
-        void add(Object value) {
-            contents.add(value);
-            width += width(value) + (contents.isEmpty() ? 0 : 2);
-        }
-
-        int write(Writer writer, int space, int indent) throws IOException {
-            writer.append(prefix);
-            if (width <= space) {
-                // We've sufficient room on this line, so write everything on one line.
-
-                // Take into account the suffix length here, as we ignore it the case we wrap.
-                space -= prefix.length() + suffix.length();
-
-                var comma = false;
-                for (var value : contents) {
-                    if (comma) {
-                        writer.append(", ");
-                        space -= 2;
-                    }
-                    comma = true;
-
-                    space = PrettyJsonWriter.write(writer, value, space, indent);
-                }
-            } else {
-                // We've run out of room, so write each value on separate lines.
-                var indentStr = " ".repeat(indent);
-                writer.append("\n  ").append(indentStr);
-
-                var comma = false;
-                for (var value : contents) {
-                    if (comma) {
-                        writer.append(",\n  ").append(indentStr);
-                    }
-                    comma = true;
-
-                    PrettyJsonWriter.write(writer, value, MAX_WIDTH - indent - 2, indent + 2);
-                }
-                writer.append("\n").append(indentStr);
-            }
-
-            writer.append(suffix);
-            return space;
-        }
-    }
-
-    /**
-     * Estimate the width of an object.
-     *
-     * @param object The object to emit.
-     * @return The computed width.
-     */
-    private static int width(Object object) {
-        if (object instanceof String string) return string.length();
-        if (object instanceof DocList list) return list.width;
-        if (object instanceof Pair pair) return pair.width();
-        throw new IllegalArgumentException("Not a valid document");
-    }
-
-    /**
-     * Write a value to the output stream.
-     *
-     * @param writer The writer to emit to.
-     * @param object The object to write.
-     * @param space  The amount of space left on this line. Will be no larger than {@link #MAX_WIDTH}, but may be negative.
-     * @param indent The current indent.
-     * @return The new amount of space left on this line. This is undefined if the writer wraps.
-     * @throws IOException If the underlying writer fails.
-     */
-    private static int write(Writer writer, Object object, int space, int indent) throws IOException {
-        if (object instanceof String str) {
-            writer.write(str);
-            return space - str.length();
-        } else if (object instanceof DocList list) {
-            return list.write(writer, space, indent);
-        } else if (object instanceof Pair pair) {
-            return pair.write(writer, space, indent);
-        } else {
-            throw new IllegalArgumentException("Not a valid document");
-        }
-    }
-
-    private static String escapeString(String value) {
-        var builder = new StringBuilder();
-        builder.append('\"');
-
-        var length = value.length();
-        for (var i = 0; i < length; i++) {
-            var c = value.charAt(i);
-            String replacement = null;
-            if (c < STRING_REPLACE.length) {
-                replacement = STRING_REPLACE[c];
-            } else if (c == '\u2028') {
-                replacement = "\\u2028";
-            } else if (c == '\u2029') {
-                replacement = "\\u2029";
-            }
-
-            if (replacement == null) {
-                builder.append(c);
-            } else {
-                builder.append(replacement);
-            }
-        }
-
-        builder.append('\"');
-        return builder.toString();
-    }
-
-    private static final String[] STRING_REPLACE = new String[128];
-
-    static {
-        for (var i = 0; i <= 0x1f; i++) STRING_REPLACE[i] = String.format("\\u%04x", i);
-        STRING_REPLACE['"'] = "\\\"";
-        STRING_REPLACE['\\'] = "\\\\";
-        STRING_REPLACE['\t'] = "\\t";
-        STRING_REPLACE['\b'] = "\\b";
-        STRING_REPLACE['\n'] = "\\n";
-        STRING_REPLACE['\r'] = "\\r";
-        STRING_REPLACE['\f'] = "\\f";
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/RecipeProvider.java

@@ -1,477 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.pocket.PocketUpgradeDataProvider;
-import dan200.computercraft.api.turtle.TurtleUpgradeDataProvider;
-import dan200.computercraft.core.util.Colour;
-import dan200.computercraft.shared.ModRegistry;
-import dan200.computercraft.shared.common.IColouredItem;
-import dan200.computercraft.shared.computer.core.ComputerFamily;
-import dan200.computercraft.shared.platform.PlatformHelper;
-import dan200.computercraft.shared.platform.RecipeIngredients;
-import dan200.computercraft.shared.platform.RegistryWrappers;
-import dan200.computercraft.shared.pocket.items.PocketComputerItemFactory;
-import dan200.computercraft.shared.turtle.items.TurtleItemFactory;
-import net.minecraft.advancements.critereon.InventoryChangeTrigger;
-import net.minecraft.advancements.critereon.ItemPredicate;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.data.PackOutput;
-import net.minecraft.data.recipes.*;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.tags.TagKey;
-import net.minecraft.util.GsonHelper;
-import net.minecraft.world.item.DyeColor;
-import net.minecraft.world.item.DyeItem;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.Items;
-import net.minecraft.world.item.crafting.Ingredient;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraft.world.item.crafting.ShapedRecipe;
-import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
-import net.minecraft.world.level.ItemLike;
-import net.minecraft.world.level.block.Blocks;
-
-import java.util.Locale;
-import java.util.function.Consumer;
-
-import static dan200.computercraft.api.ComputerCraftTags.Items.COMPUTER;
-import static dan200.computercraft.api.ComputerCraftTags.Items.WIRED_MODEM;
-
-class RecipeProvider extends net.minecraft.data.recipes.RecipeProvider {
-    private final RecipeIngredients ingredients = PlatformHelper.get().getRecipeIngredients();
-    private final TurtleUpgradeDataProvider turtleUpgrades;
-    private final PocketUpgradeDataProvider pocketUpgrades;
-
-    RecipeProvider(PackOutput output, TurtleUpgradeDataProvider turtleUpgrades, PocketUpgradeDataProvider pocketUpgrades) {
-        super(output);
-        this.turtleUpgrades = turtleUpgrades;
-        this.pocketUpgrades = pocketUpgrades;
-    }
-
-    @Override
-    public void buildRecipes(Consumer<FinishedRecipe> add) {
-        basicRecipes(add);
-        diskColours(add);
-        pocketUpgrades(add);
-        turtleUpgrades(add);
-
-        addSpecial(add, ModRegistry.RecipeSerializers.PRINTOUT.get());
-        addSpecial(add, ModRegistry.RecipeSerializers.DISK.get());
-        addSpecial(add, ModRegistry.RecipeSerializers.DYEABLE_ITEM.get());
-        addSpecial(add, ModRegistry.RecipeSerializers.TURTLE_UPGRADE.get());
-        addSpecial(add, ModRegistry.RecipeSerializers.POCKET_COMPUTER_UPGRADE.get());
-    }
-
-    /**
-     * Register a crafting recipe for a disk of every dye colour.
-     *
-     * @param add The callback to add recipes.
-     */
-    private void diskColours(Consumer<FinishedRecipe> add) {
-        for (var colour : Colour.VALUES) {
-            ShapelessRecipeBuilder
-                .shapeless(RecipeCategory.REDSTONE, ModRegistry.Items.DISK.get())
-                .requires(ingredients.redstone())
-                .requires(Items.PAPER)
-                .requires(DyeItem.byColor(ofColour(colour)))
-                .group("computercraft:disk")
-                .unlockedBy("has_drive", inventoryChange(ModRegistry.Blocks.DISK_DRIVE.get()))
-                .save(
-                    RecipeWrapper.wrap(ModRegistry.RecipeSerializers.IMPOSTOR_SHAPELESS.get(), add)
-                        .withResultTag(x -> x.putInt(IColouredItem.NBT_COLOUR, colour.getHex())),
-                    new ResourceLocation(ComputerCraftAPI.MOD_ID, "disk_" + (colour.ordinal() + 1))
-                );
-        }
-    }
-
-    /**
-     * Register a crafting recipe for each turtle upgrade.
-     *
-     * @param add The callback to add recipes.
-     */
-    private void turtleUpgrades(Consumer<FinishedRecipe> add) {
-        for (var family : ComputerFamily.values()) {
-            var base = TurtleItemFactory.create(-1, null, -1, family, null, null, 0, null);
-            if (base.isEmpty()) continue;
-
-            var nameId = family.name().toLowerCase(Locale.ROOT);
-
-            for (var upgrade : turtleUpgrades.getGeneratedUpgrades()) {
-                var result = TurtleItemFactory.create(-1, null, -1, family, null, upgrade, -1, null);
-                ShapedRecipeBuilder
-                    .shaped(RecipeCategory.REDSTONE, result.getItem())
-                    .group(String.format("%s:turtle_%s", ComputerCraftAPI.MOD_ID, nameId))
-                    .pattern("#T")
-                    .define('T', base.getItem())
-                    .define('#', upgrade.getCraftingItem().getItem())
-                    .unlockedBy("has_items",
-                        inventoryChange(base.getItem(), upgrade.getCraftingItem().getItem()))
-                    .save(
-                        RecipeWrapper.wrap(ModRegistry.RecipeSerializers.IMPOSTOR_SHAPED.get(), add).withResultTag(result.getTag()),
-                        new ResourceLocation(ComputerCraftAPI.MOD_ID, String.format("turtle_%s/%s/%s",
-                            nameId, upgrade.getUpgradeID().getNamespace(), upgrade.getUpgradeID().getPath()
-                        ))
-                    );
-            }
-        }
-    }
-
-    /**
-     * Register a crafting recipe for each pocket upgrade.
-     *
-     * @param add The callback to add recipes.
-     */
-    private void pocketUpgrades(Consumer<FinishedRecipe> add) {
-        for (var family : ComputerFamily.values()) {
-            var base = PocketComputerItemFactory.create(-1, null, -1, family, null);
-            if (base.isEmpty()) continue;
-
-            var nameId = family.name().toLowerCase(Locale.ROOT);
-
-            for (var upgrade : pocketUpgrades.getGeneratedUpgrades()) {
-                var result = PocketComputerItemFactory.create(-1, null, -1, family, upgrade);
-                ShapedRecipeBuilder
-                    .shaped(RecipeCategory.REDSTONE, result.getItem())
-                    .group(String.format("%s:pocket_%s", ComputerCraftAPI.MOD_ID, nameId))
-                    .pattern("#")
-                    .pattern("P")
-                    .define('P', base.getItem())
-                    .define('#', upgrade.getCraftingItem().getItem())
-                    .unlockedBy("has_items",
-                        inventoryChange(base.getItem(), upgrade.getCraftingItem().getItem()))
-                    .save(
-                        RecipeWrapper.wrap(ModRegistry.RecipeSerializers.IMPOSTOR_SHAPED.get(), add).withResultTag(result.getTag()),
-                        new ResourceLocation(ComputerCraftAPI.MOD_ID, String.format("pocket_%s/%s/%s",
-                            nameId, upgrade.getUpgradeID().getNamespace(), upgrade.getUpgradeID().getPath()
-                        ))
-                    );
-            }
-        }
-    }
-
-    private void basicRecipes(Consumer<FinishedRecipe> add) {
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Items.CABLE.get(), 6)
-            .pattern(" # ")
-            .pattern("#R#")
-            .pattern(" # ")
-            .define('#', ingredients.stone())
-            .define('R', ingredients.redstone())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .unlockedBy("has_modem", inventoryChange(WIRED_MODEM))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.COMPUTER_NORMAL.get())
-            .pattern("###")
-            .pattern("#R#")
-            .pattern("#G#")
-            .define('#', ingredients.stone())
-            .define('R', ingredients.redstone())
-            .define('G', ingredients.glassPane())
-            .unlockedBy("has_redstone", inventoryChange(itemPredicate(ingredients.redstone())))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.COMPUTER_ADVANCED.get())
-            .pattern("###")
-            .pattern("#R#")
-            .pattern("#G#")
-            .define('#', ingredients.goldIngot())
-            .define('R', ingredients.redstone())
-            .define('G', ingredients.glassPane())
-            .unlockedBy("has_components", inventoryChange(itemPredicate(ingredients.redstone()), itemPredicate(ingredients.goldIngot())))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Items.COMPUTER_ADVANCED.get())
-            .pattern("###")
-            .pattern("#C#")
-            .pattern("# #")
-            .define('#', ingredients.goldIngot())
-            .define('C', ModRegistry.Items.COMPUTER_NORMAL.get())
-            .unlockedBy("has_components", inventoryChange(itemPredicate(ModRegistry.Items.COMPUTER_NORMAL.get()), itemPredicate(ingredients.goldIngot())))
-            .save(
-                RecipeWrapper.wrap(ModRegistry.RecipeSerializers.COMPUTER_UPGRADE.get(), add).withExtraData(family(ComputerFamily.ADVANCED)),
-                new ResourceLocation(ComputerCraftAPI.MOD_ID, "computer_advanced_upgrade")
-            );
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.COMPUTER_COMMAND.get())
-            .pattern("###")
-            .pattern("#R#")
-            .pattern("#G#")
-            .define('#', ingredients.goldIngot())
-            .define('R', Blocks.COMMAND_BLOCK)
-            .define('G', ingredients.glassPane())
-            .unlockedBy("has_components", inventoryChange(Blocks.COMMAND_BLOCK))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.TURTLE_NORMAL.get())
-            .pattern("###")
-            .pattern("#C#")
-            .pattern("#I#")
-            .define('#', ingredients.ironIngot())
-            .define('C', ModRegistry.Items.COMPUTER_NORMAL.get())
-            .define('I', ingredients.woodenChest())
-            .unlockedBy("has_computer", inventoryChange(ModRegistry.Items.COMPUTER_NORMAL.get()))
-            .save(RecipeWrapper.wrap(ModRegistry.RecipeSerializers.TURTLE.get(), add).withExtraData(family(ComputerFamily.NORMAL)));
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.TURTLE_ADVANCED.get())
-            .pattern("###")
-            .pattern("#C#")
-            .pattern("#I#")
-            .define('#', ingredients.goldIngot())
-            .define('C', ModRegistry.Items.COMPUTER_ADVANCED.get())
-            .define('I', ingredients.woodenChest())
-            .unlockedBy("has_computer", inventoryChange(ModRegistry.Items.COMPUTER_NORMAL.get()))
-            .save(RecipeWrapper.wrap(ModRegistry.RecipeSerializers.TURTLE.get(), add).withExtraData(family(ComputerFamily.ADVANCED)));
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.TURTLE_ADVANCED.get())
-            .pattern("###")
-            .pattern("#C#")
-            .pattern(" B ")
-            .define('#', ingredients.goldIngot())
-            .define('C', ModRegistry.Items.TURTLE_NORMAL.get())
-            .define('B', ingredients.goldBlock())
-            .unlockedBy("has_components", inventoryChange(itemPredicate(ModRegistry.Items.TURTLE_NORMAL.get()), itemPredicate(ingredients.goldIngot())))
-            .save(
-                RecipeWrapper.wrap(ModRegistry.RecipeSerializers.COMPUTER_UPGRADE.get(), add).withExtraData(family(ComputerFamily.ADVANCED)),
-                new ResourceLocation(ComputerCraftAPI.MOD_ID, "turtle_advanced_upgrade")
-            );
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.DISK_DRIVE.get())
-            .pattern("###")
-            .pattern("#R#")
-            .pattern("#R#")
-            .define('#', ingredients.stone())
-            .define('R', ingredients.redstone())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.MONITOR_NORMAL.get())
-            .pattern("###")
-            .pattern("#G#")
-            .pattern("###")
-            .define('#', ingredients.stone())
-            .define('G', ingredients.glassPane())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.MONITOR_ADVANCED.get(), 4)
-            .pattern("###")
-            .pattern("#G#")
-            .pattern("###")
-            .define('#', ingredients.goldIngot())
-            .define('G', ingredients.glassPane())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Items.POCKET_COMPUTER_NORMAL.get())
-            .pattern("###")
-            .pattern("#A#")
-            .pattern("#G#")
-            .define('#', ingredients.stone())
-            .define('A', Items.GOLDEN_APPLE)
-            .define('G', ingredients.glassPane())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .unlockedBy("has_apple", inventoryChange(Items.GOLDEN_APPLE))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Items.POCKET_COMPUTER_ADVANCED.get())
-            .pattern("###")
-            .pattern("#A#")
-            .pattern("#G#")
-            .define('#', ingredients.goldIngot())
-            .define('A', Items.GOLDEN_APPLE)
-            .define('G', ingredients.glassPane())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .unlockedBy("has_apple", inventoryChange(Items.GOLDEN_APPLE))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Items.POCKET_COMPUTER_ADVANCED.get())
-            .pattern("###")
-            .pattern("#C#")
-            .pattern("# #")
-            .define('#', ingredients.goldIngot())
-            .define('C', ModRegistry.Items.POCKET_COMPUTER_NORMAL.get())
-            .unlockedBy("has_components", inventoryChange(itemPredicate(ModRegistry.Items.POCKET_COMPUTER_NORMAL.get()), itemPredicate(ingredients.goldIngot())))
-            .save(
-                RecipeWrapper.wrap(ModRegistry.RecipeSerializers.COMPUTER_UPGRADE.get(), add).withExtraData(family(ComputerFamily.ADVANCED)),
-                new ResourceLocation(ComputerCraftAPI.MOD_ID, "pocket_computer_advanced_upgrade")
-            );
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.PRINTER.get())
-            .pattern("###")
-            .pattern("#R#")
-            .pattern("#D#")
-            .define('#', ingredients.stone())
-            .define('R', ingredients.redstone())
-            .define('D', ingredients.dye())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.SPEAKER.get())
-            .pattern("###")
-            .pattern("#N#")
-            .pattern("#R#")
-            .define('#', ingredients.stone())
-            .define('N', Blocks.NOTE_BLOCK)
-            .define('R', ingredients.redstone())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Items.WIRED_MODEM.get())
-            .pattern("###")
-            .pattern("#R#")
-            .pattern("###")
-            .define('#', ingredients.stone())
-            .define('R', ingredients.redstone())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .unlockedBy("has_cable", inventoryChange(ModRegistry.Items.CABLE.get()))
-            .save(add);
-
-        ShapelessRecipeBuilder
-            .shapeless(RecipeCategory.REDSTONE, ModRegistry.Blocks.WIRED_MODEM_FULL.get())
-            .requires(ModRegistry.Items.WIRED_MODEM.get())
-            .unlockedBy("has_modem", inventoryChange(WIRED_MODEM))
-            .save(add, new ResourceLocation(ComputerCraftAPI.MOD_ID, "wired_modem_full_from"));
-        ShapelessRecipeBuilder
-            .shapeless(RecipeCategory.REDSTONE, ModRegistry.Items.WIRED_MODEM.get())
-            .requires(ModRegistry.Blocks.WIRED_MODEM_FULL.get())
-            .unlockedBy("has_modem", inventoryChange(WIRED_MODEM))
-            .save(add, new ResourceLocation(ComputerCraftAPI.MOD_ID, "wired_modem_full_to"));
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.WIRELESS_MODEM_NORMAL.get())
-            .pattern("###")
-            .pattern("#E#")
-            .pattern("###")
-            .define('#', ingredients.stone())
-            .define('E', ingredients.enderPearl())
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .save(add);
-
-        ShapedRecipeBuilder
-            .shaped(RecipeCategory.REDSTONE, ModRegistry.Blocks.WIRELESS_MODEM_ADVANCED.get())
-            .pattern("###")
-            .pattern("#E#")
-            .pattern("###")
-            .define('#', ingredients.goldIngot())
-            .define('E', Items.ENDER_EYE)
-            .unlockedBy("has_computer", inventoryChange(COMPUTER))
-            .unlockedBy("has_wireless", inventoryChange(ModRegistry.Blocks.WIRELESS_MODEM_NORMAL.get()))
-            .save(add);
-
-        ShapelessRecipeBuilder
-            .shapeless(RecipeCategory.DECORATIONS, Items.PLAYER_HEAD)
-            .requires(ingredients.head())
-            .requires(ModRegistry.Items.MONITOR_NORMAL.get())
-            .unlockedBy("has_monitor", inventoryChange(ModRegistry.Items.MONITOR_NORMAL.get()))
-            .save(
-                RecipeWrapper.wrap(RecipeSerializer.SHAPELESS_RECIPE, add)
-                    .withResultTag(playerHead("Cloudhunter", "6d074736-b1e9-4378-a99b-bd8777821c9c")),
-                new ResourceLocation(ComputerCraftAPI.MOD_ID, "skull_cloudy")
-            );
-
-        ShapelessRecipeBuilder
-            .shapeless(RecipeCategory.DECORATIONS, Items.PLAYER_HEAD)
-            .requires(ingredients.head())
-            .requires(ModRegistry.Items.COMPUTER_ADVANCED.get())
-            .unlockedBy("has_computer", inventoryChange(ModRegistry.Items.COMPUTER_ADVANCED.get()))
-            .save(
-                RecipeWrapper.wrap(RecipeSerializer.SHAPELESS_RECIPE, add)
-                    .withResultTag(playerHead("dan200", "f3c8d69b-0776-4512-8434-d1b2165909eb")),
-                new ResourceLocation(ComputerCraftAPI.MOD_ID, "skull_dan200")
-            );
-
-        ShapelessRecipeBuilder
-            .shapeless(RecipeCategory.REDSTONE, ModRegistry.Items.PRINTED_PAGES.get())
-            .requires(ModRegistry.Items.PRINTED_PAGE.get(), 2)
-            .requires(ingredients.string())
-            .unlockedBy("has_printer", inventoryChange(ModRegistry.Blocks.PRINTER.get()))
-            .save(RecipeWrapper.wrap(ModRegistry.RecipeSerializers.IMPOSTOR_SHAPELESS.get(), add));
-
-        ShapelessRecipeBuilder
-            .shapeless(RecipeCategory.REDSTONE, ModRegistry.Items.PRINTED_BOOK.get())
-            .requires(ingredients.leather())
-            .requires(ModRegistry.Items.PRINTED_PAGE.get(), 1)
-            .requires(ingredients.string())
-            .unlockedBy("has_printer", inventoryChange(ModRegistry.Blocks.PRINTER.get()))
-            .save(RecipeWrapper.wrap(ModRegistry.RecipeSerializers.IMPOSTOR_SHAPELESS.get(), add));
-    }
-
-    private static DyeColor ofColour(Colour colour) {
-        return DyeColor.byId(15 - colour.ordinal());
-    }
-
-    private static InventoryChangeTrigger.TriggerInstance inventoryChange(TagKey<Item> stack) {
-        return InventoryChangeTrigger.TriggerInstance.hasItems(itemPredicate(stack));
-    }
-
-    private static InventoryChangeTrigger.TriggerInstance inventoryChange(ItemLike... stack) {
-        return InventoryChangeTrigger.TriggerInstance.hasItems(stack);
-    }
-
-    private static InventoryChangeTrigger.TriggerInstance inventoryChange(ItemPredicate... items) {
-        return InventoryChangeTrigger.TriggerInstance.hasItems(items);
-    }
-
-    private static ItemPredicate itemPredicate(ItemLike item) {
-        return ItemPredicate.Builder.item().of(item).build();
-    }
-
-    private static ItemPredicate itemPredicate(TagKey<Item> item) {
-        return ItemPredicate.Builder.item().of(item).build();
-    }
-
-    private static ItemPredicate itemPredicate(Ingredient ingredient) {
-        var json = ingredient.toJson();
-        if (!(json instanceof JsonObject object)) throw new IllegalStateException("Unknown ingredient " + json);
-
-        if (object.has("item")) {
-            return itemPredicate(ShapedRecipe.itemFromJson(object));
-        } else if (object.has("tag")) {
-            return itemPredicate(TagKey.create(Registries.ITEM, new ResourceLocation(GsonHelper.getAsString(object, "tag"))));
-        } else {
-            throw new IllegalArgumentException("Unknown ingredient " + json);
-        }
-    }
-
-    private static CompoundTag playerHead(String name, String uuid) {
-        var owner = new CompoundTag();
-        owner.putString("Name", name);
-        owner.putString("Id", uuid);
-
-        var tag = new CompoundTag();
-        tag.put("SkullOwner", owner);
-        return tag;
-    }
-
-    private static Consumer<JsonObject> family(ComputerFamily family) {
-        return json -> json.addProperty("family", family.toString());
-    }
-
-    private static void addSpecial(Consumer<FinishedRecipe> add, SimpleCraftingRecipeSerializer<?> special) {
-        SpecialRecipeBuilder.special(special).save(add, RegistryWrappers.RECIPE_SERIALIZERS.getKey(special).toString());
-    }
-}

projects/common/src/main/java/dan200/computercraft/data/RecipeWrapper.java

@@ -1,94 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2022. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-package dan200.computercraft.data;
-
-import com.google.gson.JsonObject;
-import net.minecraft.data.recipes.FinishedRecipe;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.util.GsonHelper;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-
-/**
- * Adapter for recipes which overrides the serializer and adds custom item NBT.
- */
-final class RecipeWrapper implements Consumer<FinishedRecipe> {
-    private final Consumer<FinishedRecipe> add;
-    private final RecipeSerializer<?> serializer;
-    private final List<Consumer<JsonObject>> extend = new ArrayList<>(0);
-
-    RecipeWrapper(Consumer<FinishedRecipe> add, RecipeSerializer<?> serializer) {
-        this.add = add;
-        this.serializer = serializer;
-    }
-
-    public static RecipeWrapper wrap(RecipeSerializer<?> serializer, Consumer<FinishedRecipe> original) {
-        return new RecipeWrapper(original, serializer);
-    }
-
-    public RecipeWrapper withExtraData(Consumer<JsonObject> extra) {
-        extend.add(extra);
-        return this;
-    }
-
-    public RecipeWrapper withResultTag(@Nullable CompoundTag resultTag) {
-        if (resultTag == null) return this;
-
-        extend.add(json -> {
-            var object = GsonHelper.getAsJsonObject(json, "result");
-            object.addProperty("nbt", resultTag.toString());
-        });
-        return this;
-    }
-
-    public RecipeWrapper withResultTag(Consumer<CompoundTag> resultTag) {
-        var tag = new CompoundTag();
-        resultTag.accept(tag);
-        return withResultTag(tag);
-    }
-
-    @Override
-    public void accept(FinishedRecipe finishedRecipe) {
-        add.accept(new RecipeImpl(finishedRecipe, serializer, extend));
-    }
-
-    private record RecipeImpl(
-        FinishedRecipe recipe, RecipeSerializer<?> serializer, List<Consumer<JsonObject>> extend
-    ) implements FinishedRecipe {
-        @Override
-        public void serializeRecipeData(JsonObject jsonObject) {
-            recipe.serializeRecipeData(jsonObject);
-            for (var extender : extend) extender.accept(jsonObject);
-        }
-
-        @Override
-        public ResourceLocation getId() {
-            return recipe.getId();
-        }
-
-        @Override
-        public RecipeSerializer<?> getType() {
-            return serializer;
-        }
-
-        @Nullable
-        @Override
-        public JsonObject serializeAdvancement() {
-            return recipe.serializeAdvancement();
-        }
-
-        @Nullable
-        @Override
-        public ResourceLocation getAdvancementId() {
-            return recipe.getAdvancementId();
-        }
-    }
-}