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

0/10, would not recommend.

.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,25 +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: Prepare Jars
-      run: |
-        # Find the main jar and append the git hash onto it.
-        mkdir -p jars
-        find projects/forge/build/libs projects/fabric/build/libs -type f -regex '.*[0-9.]+\(-SNAPSHOT\)?\.jar$' -exec bash -c 'cp {} "jars/$(basename {} .jar)-$(git rev-parse HEAD).jar"' \;
-
     - name: Upload Jar
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v2
       with:
         name: CC-Tweaked
-        path: ./jars
+        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
@@ -59,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.
@@ -34,7 +35,7 @@ abstract class CheckChangelog : DefaultTask() {
 
         var ok = true
 
-        // Check we're targeting the current version
+        // Check we're targetting the current version
         var whatsNew = whatsNew.get().asFile.readLines()
         if (whatsNew[0] != "New features in CC: Tweaked $version") {
             ok = false

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>

doc/events/alarm.md

@@ -3,20 +3,19 @@ module: [kind=event] alarm
 see: os.setAlarm To start an alarm.
 ---
 
-The @{alarm} event is fired when an alarm started with @{os.setAlarm} completes.
+The @{timer} event is fired when an alarm started with @{os.setAlarm} completes.
 
 ## Return Values
 1. @{string}: The event name.
 2. @{number}: The ID of the alarm that finished.
 
 ## Example
-Starts a timer and then waits for it to complete.
-
+Starts a timer and then prints its ID:
 ```lua
-local alarm_id = os.setAlarm(os.time() + 0.05)
+local alarmID = os.setAlarm(os.time() + 0.05)
 local event, id
 repeat
     event, id = os.pullEvent("alarm")
-until id == alarm_id
+until id == alarmID
 print("Alarm with ID " .. id .. " was fired")
 ```

doc/events/char.md

@@ -3,7 +3,7 @@ module: [kind=event] char
 see: key To listen to any key press.
 ---
 
-The @{char} event is fired when a character is typed on the keyboard.
+The @{char} event is fired when a character is _typed_ on the keyboard.
 
 The @{char} event is different to a key press. Sometimes multiple key presses may result in one character being
 typed (for instance, on some European keyboards). Similarly, some keys (e.g. <kbd>Ctrl</kbd>) do not have any
@@ -16,10 +16,9 @@ corresponding character. The @{key} should be used if you want to listen to key
 
 ## Example
 Prints each character the user presses:
-
 ```lua
 while true do
-    local event, character = os.pullEvent("char")
-    print(character .. " was pressed.")
+  local event, character = os.pullEvent("char")
+  print(character .. " was pressed.")
 end
 ```

doc/events/computer_command.md

@@ -6,7 +6,7 @@ The @{computer_command} event is fired when the `/computercraft queue` command i
 
 ## Return Values
 1. @{string}: The event name.
-2. @{string}<abbr title="Variable number of arguments">&hellip;</abbr>: The arguments passed to the command.
+... @{string}: The arguments passed to the command.
 
 ## Example
 Prints the contents of messages sent:

doc/events/file_transfer.md

@@ -5,9 +5,9 @@ since: 1.101.0
 
 The @{file_transfer} event is queued when a user drags-and-drops a file on an open computer.
 
-This event contains a single argument of type @{TransferredFiles}, which can be used to @{TransferredFiles.getFiles|get
-the files to be transferred}. Each file returned is a @{fs.BinaryReadHandle|binary file handle} with an additional
-@{TransferredFile.getName|getName} method.
+This event contains a single argument, that in turn has a single method @{TransferredFiles.getFiles|getFiles}. This
+returns the list of files that are being transferred. Each file is a @{fs.BinaryReadHandle|binary file handle} with an
+additional @{TransferredFile.getName|getName} method.
 
 ## Return values
 1. @{string}: The event name

doc/events/http_check.md

@@ -11,4 +11,4 @@ This event is normally handled inside @{http.checkURL}, but it can still be seen
 1. @{string}: The event name.
 2. @{string}: The URL requested to be checked.
 3. @{boolean}: Whether the check succeeded.
-4. <span class="type">@{string}|@{nil}</span>: If the check failed, a reason explaining why the check failed.
+4. @{string|nil}: If the check failed, a reason explaining why the check failed.

doc/events/http_failure.md

@@ -11,8 +11,7 @@ This event is normally handled inside @{http.get} and @{http.post}, but it can s
 1. @{string}: The event name.
 2. @{string}: The URL of the site requested.
 3. @{string}: An error describing the failure.
-4. <span class="type">@{http.Response}|@{nil}</span>: A response handle if the connection succeeded, but the server's
-   response indicated failure.
+4. @{http.Response|nil}: A response handle if the connection succeeded, but the server's response indicated failure.
 
 ## Example
 Prints an error why the website cannot be contacted:

doc/events/http_success.md

@@ -10,7 +10,7 @@ This event is normally handled inside @{http.get} and @{http.post}, but it can s
 ## Return Values
 1. @{string}: The event name.
 2. @{string}: The URL of the site requested.
-3. @{http.Response}: The successful HTTP response.
+3. @{http.Response}: The handle for the response text.
 
 ## Example
 Prints the content of a website (this may fail if the request fails):

doc/events/modem_message.md

@@ -10,7 +10,7 @@ The @{modem_message} event is fired when a message is received on an open channe
 3. @{number}: The channel that the message was sent on.
 4. @{number}: The reply channel set by the sender.
 5. @{any}: The message as sent by the sender.
-6. <span class="type">@{number}|@{nil}</span>: The distance between the sender and the receiver in blocks, or @{nil} if the message was sent between dimensions.
+6. @{number}: The distance between the sender and the receiver, in blocks.
 
 ## Example
 Wraps a @{modem} peripheral, opens channel 0 for listening, and prints all received messages.
@@ -20,9 +20,7 @@ local modem = peripheral.find("modem") or error("No modem attached", 0)
 modem.open(0)
 
 while true do
-    local event, side, channel, replyChannel, message, distance = os.pullEvent("modem_message")
-    print(("Message received on side %s on channel %d (reply to %d) from %f blocks away with message %s"):format(
-        side, channel, replyChannel, distance, tostring(message)
-    ))
+  local event, side, channel, replyChannel, message, distance = os.pullEvent("modem_message")
+  print(("Message received on side %s on channel %d (reply to %d) from %f blocks away with message %s"):format(side, channel, replyChannel, distance, tostring(message)))
 end
 ```

doc/events/monitor_resize.md

@@ -6,11 +6,10 @@ The @{monitor_resize} event is fired when an adjacent or networked monitor's siz
 
 ## Return Values
 1. @{string}: The event name.
-2. @{string}: The side or network ID of the monitor that was resized.
+2. @{string}: The side or network ID of the monitor that resized.
 
 ## Example
 Prints a message when a monitor is resized:
-
 ```lua
 while true do
   local event, side = os.pullEvent("monitor_resize")

doc/events/rednet_message.md

@@ -14,7 +14,7 @@ This event is usually handled by @{rednet.receive}, but it can also be pulled ma
 1. @{string}: The event name.
 2. @{number}: The ID of the sending computer.
 3. @{any}: The message sent.
-4. <span class="type">@{string}|@{nil}</span>: The protocol of the message, if provided.
+4. @{string|nil}: The protocol of the message, if provided.
 
 ## Example
 Prints a message when one is sent:

doc/events/redstone.md

@@ -4,9 +4,6 @@ module: [kind=event] redstone
 
 The @{event!redstone} event is fired whenever any redstone inputs on the computer change.
 
-## Return values
-1. @{string}: The event name.
-
 ## Example
 Prints a message when a redstone input changes:
 ```lua

doc/events/task_complete.md

@@ -10,7 +10,7 @@ The @{task_complete} event is fired when an asynchronous task completes. This is
 2. @{number}: The ID of the task that completed.
 3. @{boolean}: Whether the command succeeded.
 4. @{string}: If the command failed, an error message explaining the failure. (This is not present if the command succeeded.)
-5. <abbr title="Variable number of arguments">&hellip;</abbr>: Any parameters returned from the command.
+...: Any parameters returned from the command.
 
 ## Example
 Prints the results of an asynchronous command:

doc/events/term_resize.md

@@ -9,12 +9,8 @@ The @{term_resize} event is fired when the main terminal is resized. For instanc
 When this event fires, some parts of the terminal may have been moved or deleted. Simple terminal programs (those
 not using @{term.setCursorPos}) can ignore this event, but more complex GUI programs should redraw the entire screen.
 
-## Return values
-1. @{string}: The event name.
-
 ## Example
-Print a message each time the terminal is resized.
-
+Prints :
 ```lua
 while true do
   os.pullEvent("term_resize")

doc/events/terminate.md

@@ -8,9 +8,6 @@ This event is normally handled by @{os.pullEvent}, and will not be returned. How
 
 @{terminate} will be sent even when a filter is provided to @{os.pullEventRaw}. When using @{os.pullEventRaw} with a filter, make sure to check that the event is not @{terminate}.
 
-## Return values
-1. @{string}: The event name.
-
 ## Example
 Prints a message when Ctrl-T is held:
 ```lua

doc/events/timer.md

@@ -10,12 +10,12 @@ The @{timer} event is fired when a timer started with @{os.startTimer} completes
 2. @{number}: The ID of the timer that finished.
 
 ## Example
-Start and wait for a timer to finish.
+Starts a timer and then prints its ID:
 ```lua
-local timer_id = os.startTimer(2)
+local timerID = os.startTimer(2)
 local event, id
 repeat
     event, id = os.pullEvent("timer")
-until id == timer_id
+until id == timerID
 print("Timer with ID " .. id .. " was fired")
 ```

doc/events/turtle_inventory.md

@@ -4,9 +4,6 @@ module: [kind=event] turtle_inventory
 
 The @{turtle_inventory} event is fired when a turtle's inventory is changed.
 
-## Return values
-1. @{string}: The event name.
-
 ## Example
 Prints a message when the inventory is changed:
 ```lua

doc/guides/local_ips.md

@@ -25,7 +25,7 @@ single-player or multiplayer. Look for lines that look like this:
 ```
 
 On 1.95.0 and later, this will be a single entry with `host = "$private"`. On earlier versions, this will be a number of
-`[[http.rules]]` with various IP addresses. You will want to remove all of the `[[http.rules]]` entries that have
+`[[http.rules]]` with various IP addresses. You will want to remove all of the `[[http.rules]]` entires that have
 `action = "deny"`. Then save the file and relaunch Minecraft (Server).
 
 Here's what it should look like after removing:
@@ -54,7 +54,7 @@ like this:
 ```toml
 #A list of wildcards for domains or IP ranges that cannot be accessed through the "http" API on Computers.
 #If this is empty then all whitelisted domains will be accessible. Example: "*.github.com" will block access to all subdomains of github.com.
-#You can use domain names ("pastebin.com"), wildcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
+#You can use domain names ("pastebin.com"), wilcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
 blacklist = ["127.0.0.0/8", "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "fd00::/8"]
 ```
 
@@ -65,7 +65,7 @@ Here's what it should look like after removing:
 ```toml
 #A list of wildcards for domains or IP ranges that cannot be accessed through the "http" API on Computers.
 #If this is empty then all whitelisted domains will be accessible. Example: "*.github.com" will block access to all subdomains of github.com.
-#You can use domain names ("pastebin.com"), wildcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
+#You can use domain names ("pastebin.com"), wilcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
 blacklist = []
 ```
 

gradle.properties

@@ -5,8 +5,7 @@ kotlin.stdlib.default.dependency=false
 kotlin.jvm.target.validation.mode=error
 
 # Mod properties
-isUnstable=false
-modVersion=1.103.0
+modVersion=1.101.3
 
 # 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,153 +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.1.0"
-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.6.0"
-fastutil = "8.5.9"
-guava = "31.1-jre"
 jetbrainsAnnotations = "23.0.0"
-jsr305 = "3.0.2"
-kotlin = "1.8.0"
-kotlin-coroutines = "1.6.4"
-netty = "4.1.82.Final"
-nightConfig = "3.6.5"
-slf4j = "1.7.36"
-
-# Minecraft mods
-forgeConfig = "5.0.4"
-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"
+kotlin = "1.7.10"
+kotlin-coroutines = "1.6.0"
 
 # Testing
-byteBuddy = "1.12.19"
 hamcrest = "2.2"
 jqwik = "1.7.0"
 junit = "5.9.1"
 
 # Build tools
-cctJavadoc = "1.6.0"
+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-13-g689d73d"
+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-platform = { module = "org.jetbrains.kotlin:kotlin-bom", version.ref = "kotlin" }
 kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
-kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", 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" }
+kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk8", version.ref = "kotlin" }
 
 # 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,72 +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.InteractionHand;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.context.UseOnContext;
-import net.minecraft.world.level.Level;
-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");
-
-        /**
-         * Items which can be {@linkplain Item#use(Level, Player, InteractionHand) used} when calling
-         * {@code turtle.place()}.
-         * <p>
-         * This does not cover items who handle placing inside {@link Item#useOn(UseOnContext)}, as that is always
-         * called.
-         */
-        public static final TagKey<Item> TURTLE_CAN_PLACE = make("turtle_can_place");
-
-        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 been generated yet");
-        return upgrades;
-    }
-
-    /**
-     * A constructed upgrade instance, produced {@link #addUpgrades(Consumer)}.
-     *
-     * @param id         The ID for this upgrade.
-     * @param serialiser The serialiser which reads and writes this upgrade.
-     * @param serialise  Augment the generated JSON with additional fields.
-     * @param <R>        The type of upgrade serialiser.
-     */
-    public record Upgrade<R extends UpgradeSerialiser<?>>(
-        ResourceLocation id, R serialiser, Consumer<JsonObject> serialise
-    ) {
-        /**
-         * Convenience method for registering an upgrade.
-         *
-         * @param add The callback given to {@link #addUpgrades(Consumer)}
-         */
-        public void add(Consumer<Upgrade<R>> add) {
-            add.accept(this);
-        }
-    }
-}

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,293 +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 static final float KEY_SUPPRESS_DELAY = 0.2f;
-
-    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;
-                }
-                case GLFW.GLFW_KEY_S -> {
-                    if (shutdownTimer < 0) shutdownTimer = 0;
-                }
-                case GLFW.GLFW_KEY_R -> {
-                    if (rebootTimer < 0) rebootTimer = 0;
-                }
-                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 < KEY_SUPPRESS_DELAY && rebootTimer < KEY_SUPPRESS_DELAY && shutdownTimer < KEY_SUPPRESS_DELAY) {
-            // 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,121 +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 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 christmas = Holiday.getCurrent() == Holiday.CHRISTMAS;
-
-        if (!(stack.getItem() instanceof TurtleItem turtle)) {
-            return new Combination(false, null, null, null, christmas, false);
-        }
-
-        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 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,187 +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 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, Holiday.getCurrent() == 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();
-    }
-}