Fix peripheral.getMethods returning {}

I don't even know how this snuck past.

Closes #346

.editorconfig

@@ -11,5 +11,8 @@ insert_final_newline = true
 [*.md]
 trim_trailing_whitespace = false
 
+[*.sexp]
+indent_size = 2
+
 [*.properties]
 insert_final_newline = false

.github/workflows/main-ci.yml

@@ -0,0 +1,39 @@
+name: Build
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Set up JDK 1.8
+      uses: actions/setup-java@v1
+      with:
+        java-version: 1.8
+
+    - name: Build with Gradle
+      run: ./gradlew build --no-daemon
+
+    - name: Upload Jar
+      uses: actions/upload-artifact@v1
+      with:
+        name: CC-Tweaked
+        path: build/libs
+
+  lint-lua:
+    name: Lint Lua
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Lint Lua code
+      run: |
+        test -d bin || mkdir bin
+        test -f bin/illuaminate || wget -q -Obin/illuaminate https://squiddev.cc/illuaminate/bin/illuaminate
+        chmod +x bin/illuaminate
+        bin/illuaminate lint

.gitignore

@@ -15,3 +15,9 @@
 .idea
 .gradle
 *.DS_Store
+
+.classpath
+.project
+.settings/
+bin/
+*.launch

.luacheckrc

@@ -1,34 +0,0 @@
-std = "max"
-
-ignore = {
-    -- Allow access to undefined globals or their fields. In the future we'll
-    -- define all of CC's globals within this file
-    '113', '143',
-
-    -- FIXME: Ignore unused arguments and loop variables
-    '212', '213',
-
-    -- Disable line is too long for now. It would be possible to clean
-    -- this up in the future.
-    '631',
-}
-
--- Only run the linter on ROM and bios for now, as the treasure disks
--- are largely unsupported.
-include_files = {
-    'src/main/resources/assets/computercraft/lua/rom',
-    'src/main/resources/assets/computercraft/lua/bios.lua'
-}
-
-files['src/main/resources/assets/computercraft/lua/bios.lua'] = {
-    -- Allow declaring and mutating globals
-    allow_defined_top = true,
-    ignore = { '112', '121', '122', '131', '142' },
-}
-
-files['src/main/resources/assets/computercraft/lua/rom/apis'] = {
-    -- APIs may define globals on the top level. We'll ignore unused globals,
-    -- as obviously they may be used outside that API.
-    allow_defined_top = true,
-    ignore = { '131' },
-}

.travis.yml

@@ -1,14 +0,0 @@
-language: java
-
-script: ./gradlew build --no-daemon
-
-before_cache:
-  - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
-  - rm -fr $HOME/.gradle/caches/*/plugin-resolution/
-cache:
-  directories:
-    - $HOME/.gradle/caches/
-    - $HOME/.gradle/wrapper/s
-
-jdk:
-    - oraclejdk8

README.md

@@ -1,7 +1,75 @@
-# CC:T for Fabric
+# ![CC: Tweaked](logo.png)
+[![Current build status](https://github.com/SquidDev-CC/CC-Tweaked/workflows/Build/badge.svg)](https://github.com/SquidDev-CC/CC-Tweaked/actions "Current build status") [![Download CC: Tweaked on CurseForge](http://cf.way2muchnoise.eu/title/cc-tweaked.svg)](https://minecraft.curseforge.com/projects/cc-tweaked "Download CC: Tweaked on CurseForge")
 
-* [Download on CurseForge](https://www.curseforge.com/minecraft/mc-mods/cc-restitched)
+CC: Tweaked is a fork of [ComputerCraft](https://github.com/dan200/ComputerCraft), adding programmable computers,
+turtles and more to Minecraft.
 
-A fork of [CC: Tweaked](https://github.com/SquidDev-CC/CC-Tweaked) for use with the latest Fabric.
+## What?
+ComputerCraft has always held a fond place in my heart: it's the mod which really got me into Minecraft, and it's the
+mod which has kept me playing it for many years. However, development of the original mod has slowed, as the original
+developers have had less time to work on the mod, and moved onto other projects and commitments.
 
-NOTE: This project is currently in alpha stage. It may not be well-tested and stable, so use it at your own peril!
+CC: Tweaked (or CC:T for short) is an attempt to continue ComputerCraft's legacy. It's not intended to be a competitor
+to CC, nor do I want to take it in a vastly different direction to the original mod. Instead, CC:T focuses on making the
+ComputerCraft experience as _solid_ as possible, ironing out any wrinkles that may have developed over time.
+
+## Features
+CC: Tweaked contains all the features of the latest version of ComputerCraft, as well as numerous fixes, performance
+improvements and several nifty additions. I'd recommend checking out [the releases page](https://github.com/SquidDev-CC/CC-Tweaked/releases)
+to see the full set of changes, but here's a couple of the more interesting additions:
+
+ - Improvements to the `http` library, including websockets, support for other HTTP methods (`PUT`, `DELETE`, etc...)
+   and configurable limits on HTTP usage.
+ - Full-block wired modems, allowing one to wrap non-solid peripherals (such as turtles, or chests if Plethora is
+   installed).
+ - Pocket computers can be held like maps, allowing you to view the screen without entering a GUI.
+ - Printed pages and books can be placed in item frames and held like maps.
+ - Several profiling and administration tools for server owners, via the `/computercraft` command. This allows operators
+   to track which computers are hogging resources, turn on and shutdown multiple computers at once and interact with
+   computers remotely.
+ - Closer emulation of standard Lua, adding the `debug` and `io` libraries. This also enables seeking within binary
+   files, meaning you don't need to read large files into memory.
+ - Allow running multiple computers on multiple threads, reducing latency on worlds with many computers.
+
+## Relation to CCTweaks?
+This mod has nothing to do with CCTweaks, though there is no denying the name is a throwback to it. That being said,
+several features have been included, such as full block modems, the Cobalt runtime and map-like rendering for pocket
+computers.
+
+## Contributing
+Any contribution is welcome, be that using the mod, reporting bugs or contributing code. In order to start helping
+develop CC:T, you'll need to follow these steps:
+
+ - **Clone the repository:** `git clone https://github.com/SquidDev-CC/CC-Tweaked.git && cd CC-Tweaked`
+ - **Setup Forge:** `./gradlew setupDecompWorkspace`
+ - **Test your changes:** `./gradlew runClient` (or run the `GradleStart` class from your IDE).
+
+If you want to run CC:T in a normal Minecraft instance, run `./gradlew build` and copy the `.jar` from `build/libs`.
+
+## Community
+If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
+ComputerCraft we have a [forum](https://forums.computercraft.cc/) and [Discord guild](https://discord.gg/H2UyJXe)!
+There's also a fairly populated, albeit quiet [IRC channel](http://webchat.esper.net/?channels=#computercraft), if
+that's more your cup of tea.
+
+I'd generally recommend you don't contact me directly (email, DM, etc...) unless absolutely necessary (i.e. in order to
+report exploits). You'll get a far quicker response if you ask the whole community!
+
+## Using
+If you want to depend on CC: Tweaked, we have a maven repo. However, you should be wary that some functionality is only
+exposed by CC:T's API and not vanilla ComputerCraft. If you wish to support all variations of ComputerCraft, I recommend
+using [cc.crzd.me's maven](https://cc.crzd.me/maven/) instead.
+
+```groovy
+dependencies {
+  maven { url 'https://squiddev.cc/maven/' }
+}
+
+dependencies {
+  implementation "org.squiddev:cc-tweaked-${mc_version}:${cct_version}"
+}
+```
+
+You should also be careful to only use classes within the `dan200.computercraft.api` package. Non-API classes are
+subject to change at any point. If you depend on functionality outside the API, file an issue, and we can look into
+exposing more features.

build.gradle

@@ -1,117 +1,433 @@
-plugins {
-    id 'fabric-loom' version '0.5-SNAPSHOT'
-    id 'maven-publish'
+
+// For those who want the bleeding edge
+buildscript {
+    repositories {
+        jcenter()
+        maven {
+            name = "forge"
+            url = "https://files.minecraftforge.net/maven"
+        }
+    }
+    dependencies {
+        classpath 'com.google.code.gson:gson:2.8.1'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
+        classpath 'net.sf.proguard:proguard-gradle:6.1.0beta1'
+        classpath 'org.ajoberstar.grgit:grgit-gradle:3.0.0'
+    }
 }
 
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
+plugins {
+    id "checkstyle"
+    id "com.github.hierynomus.license" version "0.15.0"
+    id "com.matthewprenger.cursegradle" version "1.3.0"
+    id "com.github.breadmoirai.github-release" version "2.2.4"
+}
+
+apply plugin: 'net.minecraftforge.gradle.forge'
+apply plugin: 'org.ajoberstar.grgit'
+apply plugin: 'maven-publish'
+apply plugin: 'maven'
 
 version = mod_version
 
-group = "dan200.computercraft"
-archivesBaseName = "cc-tweaked-fabric-${mc_version}"
+group = "org.squiddev"
+archivesBaseName = "cc-tweaked-${mc_version}"
+
+minecraft {
+    version = "${mc_version}-${forge_version}"
+    runDir = "run"
+    replace '${version}', mod_version
+
+    mappings = mappings_version
+    makeObfSourceJar = false
+}
 
 repositories {
-    mavenCentral()
+    maven {
+        name "JEI"
+        url "https://dvs1.progwml6.com/files/maven"
+    }
     maven {
         name "SquidDev"
         url "https://squiddev.cc/maven"
     }
+    ivy {
+        name "Charset"
+        artifactPattern "https://asie.pl/files/mods/Charset/LibOnly/[module]-[revision](-[classifier]).[ext]"
+    }
+    maven {
+        name "Amadornes"
+        url "https://maven.amadornes.com/"
+    }
+    maven {
+        name "CraftTweaker"
+        url "https://maven.blamejared.com/"
+    }
 }
 
 configurations {
+    shade
     compile.extendsFrom shade
+    deployerJars
 }
 
 dependencies {
-    minecraft "com.mojang:minecraft:${mc_version}"
-    mappings "net.fabricmc:yarn:${mc_version}+build.${mappings_version}:v2"
-    modImplementation "net.fabricmc:fabric-loader:${fabric_loader_version}"
-    modImplementation "net.fabricmc.fabric-api:fabric-api:${fabric_api_version}"
+    checkstyle "com.puppycrawl.tools:checkstyle:8.25"
 
-    modImplementation "me.shedaniel.cloth:config-2:${cloth_config_version}"
-    modImplementation "io.github.prospector:modmenu:${modmenu_version}"
+    deobfProvided "CraftTweaker2:CraftTweaker2-MC1120-Main:1.12-4.1.20.554"
+    deobfProvided "MCMultiPart2:MCMultiPart:2.5.3"
+    deobfProvided "mezz.jei:jei_1.12.2:4.15.0.269:api"
+    deobfProvided "pl.asie:Charset-Lib:0.5.4.6"
 
-    modApi "me.shedaniel.cloth.api:cloth-utils-v1:${project.cloth_api_version}"
-    include "me.shedaniel.cloth.api:cloth-utils-v1:${project.cloth_api_version}"
+    runtime "mezz.jei:jei_1.12.2:4.15.0.269"
 
-    implementation "blue.endless:jankson:${jankson_version}"
-    implementation 'com.google.code.findbugs:jsr305:3.0.2'
+    shade 'org.squiddev:Cobalt:0.5.0-SNAPSHOT'
 
-    include "me.shedaniel.cloth:config-2:${cloth_config_version}"
-    include "blue.endless:jankson:${jankson_version}"
-    include 'javax.vecmath:vecmath:1.5.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.4.2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.4.2'
 
-    compile 'javax.vecmath:vecmath:1.5.2'
-
-    shade 'org.squiddev:Cobalt:0.5.1-SNAPSHOT'
-
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.1.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.1.0'
-
-    modRuntime "me.shedaniel:RoughlyEnoughItems-api:5.2.10"
-    modRuntime "me.shedaniel:RoughlyEnoughItems:5.2.10"
+    deployerJars "org.apache.maven.wagon:wagon-ssh:3.0.0"
 }
 
-sourceSets {
-    main {
-        java {
-            exclude 'dan200/computercraft/shared/integration'
-        }
-    }
-}
+// Compile tasks
 
-processResources {
-    inputs.property "version", project.version
-
-    from(sourceSets.main.resources.srcDirs) {
-        include "fabric.mod.json"
-        expand "version": project.version
-    }
-
-    from(sourceSets.main.resources.srcDirs) {
-        exclude "fabric.mod.json"
-    }
-}
-
-// ensure that the encoding is set to UTF-8, no matter what the system default is
-// this fixes some edge cases with special characters not displaying correctly
-// see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
-tasks.withType(JavaCompile) {
-    options.encoding = "UTF-8"
-}
-
-// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
-// if it is present.
-// If you remove this task, sources will not be generated.
-task sourcesJar(type: Jar, dependsOn: classes) {
-    classifier = "sources"
-    from sourceSets.main.allSource
+javadoc {
+    include "dan200/computercraft/api/**/*.java"
 }
 
 jar {
-    from "LICENSE"
+    dependsOn javadoc
+
+    manifest {
+        attributes('FMLAT': 'computercraft_at.cfg')
+    }
+
+    from (sourceSets.main.allSource) {
+        include "dan200/computercraft/api/**/*.java"
+    }
 
     from configurations.shade.collect { it.isDirectory() ? it : zipTree(it) }
 }
 
-// configure the maven publication
+[compileJava, compileTestJava].forEach {
+    it.configure {
+        options.compilerArgs << "-Xlint" << "-Xlint:-processing" << "-Werror"
+    }
+}
+
+
+
+import java.nio.charset.StandardCharsets
+import java.nio.file.*
+import java.util.zip.*
+
+import com.google.gson.GsonBuilder
+import com.google.gson.JsonElement
+import com.hierynomus.gradle.license.tasks.LicenseCheck
+import com.hierynomus.gradle.license.tasks.LicenseFormat
+import org.ajoberstar.grgit.Grgit
+import proguard.gradle.ProGuardTask
+
+task proguard(type: ProGuardTask, dependsOn: jar) {
+    description "Removes unused shadowed classes from the jar"
+    group "compact"
+
+    injars jar.archivePath
+    outjars "${jar.archivePath.absolutePath.replace(".jar", "")}-min.jar"
+
+    // Add the main runtime jar and all non-shadowed dependencies
+    libraryjars "${System.getProperty('java.home')}/lib/rt.jar"
+    libraryjars "${System.getProperty('java.home')}/lib/jce.jar"
+    doFirst {
+        sourceSets.main.compileClasspath
+            .filter { !it.name.contains("Cobalt") }
+            .each { libraryjars it }
+    }
+
+    // We want to avoid as much obfuscation as possible. We're only doing this to shrink code size.
+    dontobfuscate; dontoptimize; keepattributes; keepparameternames
+
+    // Proguard will remove directories by default, but that breaks JarMount.
+    keepdirectories 'assets/computercraft/lua**'
+
+    // Preserve ComputerCraft classes - we only want to strip shadowed files.
+    keep 'class dan200.computercraft.** { *; }'
+}
+
+task proguardMove(dependsOn: proguard) {
+    description "Replace the original jar with the minified version"
+    group "compact"
+
+    doLast {
+        Files.move(
+            file("${jar.archivePath.absolutePath.replace(".jar", "")}-min.jar").toPath(),
+            file(jar.archivePath).toPath(),
+            StandardCopyOption.REPLACE_EXISTING
+        )
+    }
+}
+
+reobfJar.dependsOn proguardMove
+
+processResources {
+    inputs.property "version", mod_version
+    inputs.property "mcversion", mc_version
+
+    def hash = 'none'
+    Set<String> contributors = []
+    try {
+        def grgit = Grgit.open(dir: '.')
+        hash = grgit.head().id
+
+        def blacklist = ['GitHub', 'dan200', 'Daniel Ratcliffe']
+        grgit.log().each {
+            if (!blacklist.contains(it.author.name)) contributors.add(it.author.name)
+            if (!blacklist.contains(it.committer.name)) contributors.add(it.committer.name)
+        }
+    } catch(Exception ignored) { }
+
+    inputs.property "commithash", hash
+
+    from(sourceSets.main.resources.srcDirs) {
+        include 'mcmod.info'
+        include 'assets/computercraft/lua/rom/help/credits.txt'
+
+        expand 'version': mod_version,
+               'mcversion': mc_version,
+               'gitcontributors': contributors.sort(false, String.CASE_INSENSITIVE_ORDER).join('\n')
+    }
+
+    from(sourceSets.main.resources.srcDirs) {
+        exclude 'mcmod.info'
+        exclude 'assets/computercraft/lua/rom/help/credits.txt'
+    }
+}
+
+task compressJson(dependsOn: extractAnnotationsJar) {
+    group "compact"
+    description "Minifies all JSON files, stripping whitespace"
+
+    def jarPath = file(jar.archivePath)
+
+    def tempPath = File.createTempFile("input", ".jar", temporaryDir)
+    tempPath.deleteOnExit()
+
+    def gson = new GsonBuilder().create()
+
+    doLast {
+        // Copy over all files in the current jar to the new one, running json files from GSON. As pretty printing
+        // is turned off, they should be minified.
+        new ZipFile(jarPath).withCloseable { inJar ->
+            tempPath.getParentFile().mkdirs()
+            new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(tempPath))).withCloseable { outJar ->
+                inJar.entries().each { entry ->
+                    if(entry.directory) {
+                        outJar.putNextEntry(entry)
+                    } else if(!entry.name.endsWith(".json")) {
+                        outJar.putNextEntry(entry)
+                        inJar.getInputStream(entry).withCloseable { outJar << it }
+                    } else {
+                        ZipEntry newEntry = new ZipEntry(entry.name)
+                        newEntry.setTime(entry.time)
+                        outJar.putNextEntry(newEntry)
+
+                        def element = inJar.getInputStream(entry).withCloseable { gson.fromJson(it.newReader("UTF8"), JsonElement.class) }
+                        outJar.write(gson.toJson(element).getBytes(StandardCharsets.UTF_8))
+                    }
+                }
+
+            }
+        }
+
+        // And replace the original jar again
+        Files.move(tempPath.toPath(), jarPath.toPath(), StandardCopyOption.REPLACE_EXISTING)
+    }
+}
+
+assemble.dependsOn compressJson
+
+// Check tasks
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events "skipped", "failed"
+    }
+}
+
+license {
+    mapping("java", "SLASHSTAR_STYLE")
+    strictCheck true
+
+    ext.year = Calendar.getInstance().get(Calendar.YEAR)
+}
+
+[licenseMain, licenseFormatMain].forEach {
+    it.configure {
+        include("**/*.java")
+        exclude("dan200/computercraft/api/**")
+        header rootProject.file('config/license/main.txt')
+    }
+}
+
+[licenseTest, licenseFormatTest].forEach {
+    it.configure {
+        include("**/*.java")
+        header rootProject.file('config/license/main.txt')
+    }
+}
+
+gradle.projectsEvaluated {
+    tasks.withType(LicenseFormat) {
+        outputs.upToDateWhen { false }
+    }
+}
+
+
+task licenseAPI(type: LicenseCheck);
+task licenseFormatAPI(type: LicenseFormat);
+[licenseAPI, licenseFormatAPI].forEach {
+    it.configure {
+        source = sourceSets.main.java
+        include("dan200/computercraft/api/**")
+        header rootProject.file('config/license/api.txt')
+    }
+}
+
+// Upload tasks
+
+task checkRelease {
+    group "upload"
+    description "Verifies that everything is ready for a release"
+
+    inputs.property "version", mod_version
+    inputs.file("src/main/resources/assets/computercraft/lua/rom/help/changelog.txt")
+    inputs.file("src/main/resources/assets/computercraft/lua/rom/help/whatsnew.txt")
+
+    doLast {
+        def ok = true
+
+        // Check we're targetting the current version
+        def whatsnew = new File("src/main/resources/assets/computercraft/lua/rom/help/whatsnew.txt").readLines()
+        if (whatsnew[0] != "New features in CC: Tweaked $mod_version") {
+            ok = false
+            project.logger.error("Expected `whatsnew.txt' to target $mod_version.")
+        }
+
+        // Check "read more" exists and trim it
+        def idx = whatsnew.findIndexOf { it == 'Type "help changelog" to see the full version history.' }
+        if (idx == -1) {
+            ok = false
+            project.logger.error("Must mention the changelog in whatsnew.txt")
+        } else {
+            whatsnew = whatsnew.getAt(0 ..< idx)
+        }
+
+        // Check whatsnew and changelog match.
+        def versionChangelog = "# " + whatsnew.join("\n")
+        def changelog = new File("src/main/resources/assets/computercraft/lua/rom/help/changelog.txt").getText()
+        if (!changelog.startsWith(versionChangelog)) {
+            ok = false
+            project.logger.error("whatsnew and changelog are not in sync")
+        }
+
+        if (!ok) throw new IllegalStateException("Could not check release")
+    }
+}
+check.dependsOn checkRelease
+
+curseforge {
+    apiKey = project.hasProperty('curseForgeApiKey') ? project.curseForgeApiKey : ''
+    project {
+        id = '282001'
+        releaseType = 'release'
+        changelog = "Release notes can be found on the GitHub repository (https://github.com/SquidDev-CC/CC-Tweaked/releases/tag/v${mc_version}-${mod_version})."
+
+        relations {
+            incompatible "computercraft"
+        }
+    }
+}
+
 publishing {
     publications {
         mavenJava(MavenPublication) {
-            // add all the jars that should be included when publishing to maven
-            artifact(remapJar) {
-                builtBy remapJar
-            }
-            artifact(sourcesJar) {
-                builtBy remapSourcesJar
+            from components.java
+            artifact sourceJar
+        }
+    }
+}
+
+uploadArchives {
+    repositories {
+        if(project.hasProperty('mavenUploadUrl')) {
+            mavenDeployer {
+                configuration = configurations.deployerJars
+
+                repository(url: project.property('mavenUploadUrl')) {
+                    authentication(
+                        userName: project.property('mavenUploadUser'),
+                        privateKey: project.property('mavenUploadKey'))
+                }
+
+                pom.project {
+                    name 'CC: Tweaked'
+                    packaging 'jar'
+                    description 'CC: Tweaked is a fork of ComputerCraft, adding programmable computers, turtles and more to Minecraft.'
+                    url 'https://github.com/SquidDev-CC/CC-Tweaked'
+
+                    scm {
+                        url 'https://github.com/SquidDev-CC/CC-Tweaked.git'
+                    }
+
+                    issueManagement {
+                        system 'github'
+                        url 'https://github.com/SquidDev-CC/CC-Tweaked/issues'
+                    }
+
+                    licenses {
+                        license {
+                            name 'ComputerCraft Public License, Version 1.0'
+                            url 'https://github.com/SquidDev-CC/CC-Tweaked/blob/master/LICENSE'
+                            distribution 'repo'
+                        }
+                    }
+                }
+
+                pom.whenConfigured { pom ->
+                    pom.dependencies.clear()
+                }
             }
         }
     }
-
-    // select the repositories you want to publish to
-    repositories {
-        // uncomment to publish to the local maven
-        // mavenLocal()
-    }
 }
+
+githubRelease {
+    token project.hasProperty('githubApiKey') ? project.githubApiKey : ''
+    owner 'SquidDev-CC'
+    repo 'CC-Tweaked'
+    try {
+        targetCommitish = Grgit.open(dir: '.').branch.current().name
+    } catch(Exception ignored) { }
+
+    tagName "v${mc_version}-${mod_version}"
+    releaseName "[${mc_version}] ${mod_version}"
+    body {
+        "## " + new File("src/main/resources/assets/computercraft/lua/rom/help/whatsnew.txt")
+            .readLines()
+            .takeWhile { it != 'Type "help changelog" to see the full version history.' }
+            .join("\n").trim()
+    }
+    prerelease false
+}
+
+def uploadTasks = ["uploadArchives", "curseforge", "githubRelease"]
+uploadTasks.forEach { tasks.getByName(it).dependsOn checkRelease }
+
+task uploadAll(dependsOn: uploadTasks) {
+    group "upload"
+    description "Uploads to all repositories (Maven, Curse, GitHub release)"
+}
+
+runClient.outputs.upToDateWhen { false }
+runServer.outputs.upToDateWhen { false }

config/checkstyle/checkstyle.xml

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE module PUBLIC
+    "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+    "https://checkstyle.org/dtds/configuration_1_3.dtd">
+<module name="Checker">
+    <property name="tabWidth" value="4"/>
+    <property name="charset" value="UTF-8" />
+
+    <module name="SuppressionFilter">
+        <property name="file" value="config/checkstyle/suppressions.xml" />
+    </module>
+
+    <module name="TreeWalker">
+        <!-- Annotations -->
+        <module name="AnnotationLocation" />
+        <module name="AnnotationUseStyle" />
+        <module name="MissingDeprecated" />
+        <module name="MissingOverride" />
+
+        <!-- Blocks -->
+        <module name="EmptyBlock" />
+        <module name="EmptyCatchBlock">
+            <property name="exceptionVariableName" value="ignored" />
+        </module>
+        <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">
+            <property name="option" value="alone" />
+        </module>
+
+        <!-- Class design. As if we've ever followed good practice here. -->
+        <module name="FinalClass" />
+        <module name="InterfaceIsType" />
+        <module name="MutableException" />
+        <module name="OneTopLevelClass" />
+
+        <!-- Coding -->
+        <module name="ArrayTrailingComma" />
+        <module name="EqualsHashCode" />
+        <!-- FallThrough does not handle unreachable code well -->
+        <module name="IllegalInstantiation" />
+        <module name="IllegalThrows" />
+        <module name="ModifiedControlVariable" />
+        <module name="NoClone" />
+        <module name="NoFinalizer" />
+        <module name="OneStatementPerLine" />
+        <module name="PackageDeclaration" />
+        <module name="SimplifyBooleanExpression" />
+        <module name="SimplifyBooleanReturn" />
+        <module name="StringLiteralEquality" />
+        <module name="UnnecessaryParentheses" />
+        <module name="UnnecessarySemicolonAfterTypeMemberDeclaration" />
+        <module name="UnnecessarySemicolonInTryWithResources" />
+        <module name="UnnecessarySemicolonInEnumeration" />
+
+        <!-- Imports -->
+        <module name="CustomImportOrder" />
+        <module name="IllegalImport" />
+        <module name="RedundantImport" />
+        <module name="UnusedImports" />
+
+        <!-- Javadoc -->
+        <!-- TODO: Missing* checks for the dan200.computercraft.api package? -->
+        <module name="AtclauseOrder" />
+        <module name="InvalidJavadocPosition" />
+        <module name="JavadocBlockTagLocation" />
+        <module name="JavadocMethod"/>
+        <module name="JavadocType"/>
+        <module name="JavadocStyle" />
+        <module name="NonEmptyAtclauseDescription" />
+        <module name="SingleLineJavadoc" />
+        <module name="SummaryJavadocCheck"/>
+
+        <!-- Misc -->
+        <module name="ArrayTypeStyle" />
+        <module name="CommentsIndentation" />
+        <module name="Indentation" />
+        <module name="OuterTypeFilename" />
+
+        <!-- Modifiers -->
+        <module name="ModifierOrder" />
+        <module name="RedundantModifier" />
+
+        <!-- Naming -->
+        <module name="ClassTypeParameterName" />
+        <module name="InterfaceTypeParameterName" />
+        <module name="LambdaParameterName" />
+        <module name="LocalFinalVariableName" />
+        <module name="LocalVariableName" />
+        <!-- Allow an optional m_ on private members -->
+        <module name="MemberName">
+            <property name="applyToPrivate" value="false" />
+            <property name="applyToPackage" value="false" />
+        </module>
+        <module name="MemberName">
+            <property name="format" value="^(m_)?[a-z][a-zA-Z0-9]*$" />
+            <property name="applyToPrivate" value="true" />
+            <property name="applyToPackage" value="true" />
+        </module>
+        <module name="MethodName" />
+        <module name="MethodTypeParameterName" />
+        <module name="PackageName">
+            <property name="format" value="^dan200\.computercraf(\.[a-z][a-z0-9]*)*" />
+        </module>
+        <module name="ParameterName" />
+        <module name="StaticVariableName">
+            <property name="format" value="^[a-z][a-zA-Z0-9]*|CAPABILITY(_[A-Z]+)?$" />
+            <property name="applyToPrivate" value="false" />
+        </module>
+        <module name="StaticVariableName">
+            <property name="format" value="^(s_)?[a-z][a-zA-Z0-9]*|CAPABILITY(_[A-Z]+)?$" />
+            <property name="applyToPrivate" value="true" />
+        </module>
+        <module name="TypeName" />
+
+        <!-- Whitespace -->
+        <module name="EmptyForInitializerPad"/>
+        <module name="EmptyForIteratorPad">
+            <property name="option" value="space"/>
+        </module>
+        <module name="GenericWhitespace" />
+        <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" />
+        </module>
+        <module name="NoWhitespaceBefore" />
+        <!-- TODO: Decide on an OperatorWrap style. -->
+        <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" />
+        </module>
+        <module name="SeparatorWrap">
+            <property name="option" value="nl" />
+            <property name="tokens" value="DOT,AT" />
+        </module>
+        <module name="SingleSpaceSeparator" />
+        <module name="TypecastParenPad" />
+        <module name="WhitespaceAfter">
+            <property name="tokens" value="COMMA" />
+        </module>
+        <module name="WhitespaceAround">
+            <property name="allowEmptyConstructors" value="true" />
+            <property name="ignoreEnhancedForColon" value="false" />
+            <property name="tokens" value="ASSIGN,BAND,BAND_ASSIGN,BOR,BOR_ASSIGN,BSR,BSR_ASSIGN,BXOR,BXOR_ASSIGN,COLON,DIV,DIV_ASSIGN,DO_WHILE,EQUAL,GE,GT,LAMBDA,LAND,LCURLY,LE,LITERAL_RETURN,LOR,LT,MINUS,MINUS_ASSIGN,MOD,MOD_ASSIGN,NOT_EQUAL,PLUS,PLUS_ASSIGN,QUESTION,RCURLY,SL,SLIST,SL_ASSIGN,SR,SR_ASSIGN,STAR,STAR_ASSIGN,LITERAL_ASSERT,TYPE_EXTENSION_AND" />
+        </module>
+    </module>
+
+    <module name="FileTabCharacter" />
+    <module name="NewlineAtEndOfFile" />
+    <module name="RegexpSingleline">
+        <property name="format" value="\s+$"/>
+        <property name="message" value="Trailing whitespace"/>
+    </module>
+</module>

config/checkstyle/suppressions.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE suppressions PUBLIC
+    "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
+    "https://checkstyle.org/dtds/suppressions_1_2.dtd">
+<suppressions>
+    <!-- All the config options and method fields. -->
+    <suppress checks="StaticVariableName" files=".*[\\/]ComputerCraft.java" />
+    <suppress checks="StaticVariableName" files=".*[\\/]ComputerCraftAPI.java" />
+
+    <!-- Do not check for missing package Javadoc. -->
+    <suppress checks="JavadocStyle" files=".*[\\/]package-info.java" />
+</suppressions>

config/license/api.txt

@@ -0,0 +1,3 @@
+This file is part of the public ComputerCraft API - http://www.computercraft.info
+Copyright Daniel Ratcliffe, 2011-${year}. 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.

config/license/main.txt

@@ -0,0 +1,3 @@
+This file is part of ComputerCraft - http://www.computercraft.info
+Copyright Daniel Ratcliffe, 2011-${year}. Do not distribute without permission.
+Send enquiries to dratcliffe@gmail.com

gradle.properties

@@ -1,17 +1,7 @@
-# Done to increase the memory available to gradle.
-org.gradle.jvmargs=-Xmx1G
-
 # Mod properties
-mod_version=1.91.1
+mod_version=1.86.2
 
 # Minecraft properties
-mc_version=1.16.2
-mappings_version=31
-
-# Dependencies
-cloth_config_version=4.8.1
-fabric_api_version=0.19.0+build.398-1.16
-fabric_loader_version=0.9.2+build.206
-jankson_version=1.2.0
-modmenu_version=1.14.6+
-cloth_api_version=1.4.5
+mc_version=1.12.2
+forge_version=14.23.4.2749
+mappings_version=snapshot_20180724

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Tue Jul 07 13:15:43 EDT 2020
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.6-bin.zip

illuaminate.sexp

@@ -0,0 +1,28 @@
+; -*- mode: Lisp;-*-
+
+(sources
+  /src/main/resources/assets/computercraft/lua/bios.lua
+  /src/main/resources/assets/computercraft/lua/rom/
+  /src/test/resources/test-rom)
+
+(at /
+  (linters
+    ;; It'd be nice to avoid this, but right now there's a lot of instances of
+    ;; it.
+    -var:set-loop
+
+    ;; It's useful to name arguments for documentation, so we allow this. It'd
+    ;; be good to find a compromise in the future, but this works for now.
+    -var:unused-arg))
+
+;; We disable the unused global linter in bios.lua and the APIs. In the future
+;; hopefully we'll get illuaminate to handle this.
+(at
+  (/src/main/resources/assets/computercraft/lua/bios.lua
+   /src/main/resources/assets/computercraft/lua/rom/apis/)
+  (linters -var:unused-global)
+  (lint
+    (allow-toplevel-global true)))
+
+;; These warnings are broken right now
+(at (bios.lua worm.lua) (linters -control:unreachable))

settings.gradle

@@ -1,12 +1 @@
-pluginManagement {
-    repositories {
-        jcenter()
-        maven {
-            name = 'Fabric'
-            url = 'https://maven.fabricmc.net/'
-        }
-        gradlePluginPortal()
-    }
-}
-
-rootProject.name = "cc-tweaked-fabric-${mc_version}"
+rootProject.name = "cc-tweaked-${mc_version}"

src/main/java/dan200/computercraft/CCTweaked.java

@@ -0,0 +1,29 @@
+/*
+ * This file is part of ComputerCraft - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. Do not distribute without permission.
+ * Send enquiries to dratcliffe@gmail.com
+ */
+package dan200.computercraft;
+
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.network.NetworkCheckHandler;
+import net.minecraftforge.fml.relauncher.Side;
+
+import java.util.Map;
+
+/**
+ * A stub mod for CC: Tweaked. This doesn't have any functionality (everything of note is done in
+ * {@link ComputerCraft}), but people may depend on this if they require CC: Tweaked functionality.
+ */
+@Mod(
+    modid = "cctweaked", name = ComputerCraft.NAME, version = ComputerCraft.VERSION,
+    acceptableRemoteVersions = "*"
+)
+public class CCTweaked
+{
+    @NetworkCheckHandler
+    public boolean onNetworkConnect( Map<String, String> mods, Side side )
+    {
+        return true;
+    }
+}

src/main/java/dan200/computercraft/ComputerCraft.java

@@ -3,97 +3,109 @@
  * Copyright Daniel Ratcliffe, 2011-2020. Do not distribute without permission.
  * Send enquiries to dratcliffe@gmail.com
  */
-
 package dan200.computercraft;
 
-import static dan200.computercraft.shared.ComputerCraftRegistry.ModBlocks;
-import static dan200.computercraft.shared.ComputerCraftRegistry.init;
-
-import java.nio.file.Paths;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
+import dan200.computercraft.api.filesystem.IMount;
+import dan200.computercraft.api.filesystem.IWritableMount;
+import dan200.computercraft.api.lua.ILuaAPIFactory;
+import dan200.computercraft.api.media.IMedia;
+import dan200.computercraft.api.media.IMediaProvider;
+import dan200.computercraft.api.network.IPacketNetwork;
+import dan200.computercraft.api.network.wired.IWiredElement;
+import dan200.computercraft.api.network.wired.IWiredNode;
+import dan200.computercraft.api.peripheral.IPeripheral;
+import dan200.computercraft.api.peripheral.IPeripheralProvider;
+import dan200.computercraft.api.permissions.ITurtlePermissionProvider;
+import dan200.computercraft.api.pocket.IPocketUpgrade;
+import dan200.computercraft.api.redstone.IBundledRedstoneProvider;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.event.TurtleAction;
 import dan200.computercraft.core.apis.AddressPredicate;
-import dan200.computercraft.core.apis.http.options.Action;
-import dan200.computercraft.core.apis.http.options.AddressRule;
+import dan200.computercraft.core.apis.ApiFactories;
 import dan200.computercraft.core.apis.http.websocket.Websocket;
-import dan200.computercraft.shared.common.ColourableRecipe;
+import dan200.computercraft.core.computer.MainThread;
+import dan200.computercraft.core.filesystem.ComboMount;
+import dan200.computercraft.core.filesystem.FileMount;
+import dan200.computercraft.core.filesystem.JarMount;
+import dan200.computercraft.core.tracking.Tracking;
+import dan200.computercraft.shared.*;
+import dan200.computercraft.shared.computer.blocks.BlockCommandComputer;
+import dan200.computercraft.shared.computer.blocks.BlockComputer;
 import dan200.computercraft.shared.computer.core.ClientComputerRegistry;
 import dan200.computercraft.shared.computer.core.ServerComputerRegistry;
-import dan200.computercraft.shared.computer.recipe.ComputerUpgradeRecipe;
-import dan200.computercraft.shared.data.BlockNamedEntityLootCondition;
-import dan200.computercraft.shared.data.HasComputerIdLootCondition;
-import dan200.computercraft.shared.data.PlayerCreativeLootCondition;
-import dan200.computercraft.shared.media.recipes.DiskRecipe;
-import dan200.computercraft.shared.media.recipes.PrintoutRecipe;
-import dan200.computercraft.shared.peripheral.monitor.MonitorRenderer;
+import dan200.computercraft.shared.computer.items.ItemCommandComputer;
+import dan200.computercraft.shared.computer.items.ItemComputer;
+import dan200.computercraft.shared.media.items.ItemDiskExpanded;
+import dan200.computercraft.shared.media.items.ItemDiskLegacy;
+import dan200.computercraft.shared.media.items.ItemPrintout;
+import dan200.computercraft.shared.media.items.ItemTreasureDisk;
+import dan200.computercraft.shared.peripheral.common.BlockPeripheral;
+import dan200.computercraft.shared.peripheral.common.ItemPeripheral;
+import dan200.computercraft.shared.peripheral.modem.wired.BlockCable;
+import dan200.computercraft.shared.peripheral.modem.wired.BlockWiredModemFull;
+import dan200.computercraft.shared.peripheral.modem.wired.ItemCable;
+import dan200.computercraft.shared.peripheral.modem.wireless.BlockAdvancedModem;
+import dan200.computercraft.shared.peripheral.modem.wireless.ItemAdvancedModem;
+import dan200.computercraft.shared.peripheral.modem.wireless.WirelessNetwork;
+import dan200.computercraft.shared.pocket.items.ItemPocketComputer;
 import dan200.computercraft.shared.pocket.peripherals.PocketModem;
 import dan200.computercraft.shared.pocket.peripherals.PocketSpeaker;
-import dan200.computercraft.shared.pocket.recipes.PocketComputerUpgradeRecipe;
 import dan200.computercraft.shared.proxy.ComputerCraftProxyCommon;
-import dan200.computercraft.shared.turtle.recipes.TurtleRecipe;
-import dan200.computercraft.shared.turtle.recipes.TurtleUpgradeRecipe;
-import dan200.computercraft.shared.turtle.upgrades.TurtleAxe;
-import dan200.computercraft.shared.turtle.upgrades.TurtleCraftingTable;
-import dan200.computercraft.shared.turtle.upgrades.TurtleHoe;
-import dan200.computercraft.shared.turtle.upgrades.TurtleModem;
-import dan200.computercraft.shared.turtle.upgrades.TurtleShovel;
-import dan200.computercraft.shared.turtle.upgrades.TurtleSpeaker;
-import dan200.computercraft.shared.turtle.upgrades.TurtleSword;
-import dan200.computercraft.shared.turtle.upgrades.TurtleTool;
-import dan200.computercraft.shared.util.Config;
-import dan200.computercraft.shared.util.ImpostorRecipe;
-import dan200.computercraft.shared.util.ImpostorShapelessRecipe;
-import org.apache.logging.log4j.LogManager;
+import dan200.computercraft.shared.turtle.blocks.BlockTurtle;
+import dan200.computercraft.shared.turtle.items.ItemTurtleAdvanced;
+import dan200.computercraft.shared.turtle.items.ItemTurtleLegacy;
+import dan200.computercraft.shared.turtle.items.ItemTurtleNormal;
+import dan200.computercraft.shared.turtle.upgrades.*;
+import dan200.computercraft.shared.util.CreativeTabMain;
+import dan200.computercraft.shared.util.IDAssigner;
+import dan200.computercraft.shared.util.IoUtil;
+import dan200.computercraft.shared.wired.CapabilityWiredElement;
+import dan200.computercraft.shared.wired.WiredNode;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import net.minecraftforge.fml.common.*;
+import net.minecraftforge.fml.common.event.*;
+import net.minecraftforge.fml.relauncher.Side;
 import org.apache.logging.log4j.Logger;
 
-import net.minecraft.item.ItemGroup;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.registry.Registry;
+import java.io.*;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
 
-import net.fabricmc.api.ModInitializer;
-import net.fabricmc.fabric.api.client.itemgroup.FabricItemGroupBuilder;
-import net.fabricmc.loader.api.FabricLoader;
-
-public final class ComputerCraft implements ModInitializer {
+@Mod(
+    modid = ComputerCraft.MOD_ID, name = ComputerCraft.NAME, version = ComputerCraft.VERSION,
+    guiFactory = "dan200.computercraft.client.gui.GuiConfigCC$Factory",
+    dependencies = "required:forge@[14.23.4.2746,)"
+)
+public class ComputerCraft
+{
     public static final String MOD_ID = "computercraft";
+    static final String VERSION = "${version}";
+    static final String NAME = "CC: Tweaked";
+
     // Configuration options
-    public static final String[] DEFAULT_HTTP_WHITELIST = new String[] {"*"};
+    public static final String[] DEFAULT_HTTP_WHITELIST = new String[] { "*" };
     public static final String[] DEFAULT_HTTP_BLACKLIST = new String[] {
         "127.0.0.0/8",
         "10.0.0.0/8",
         "172.16.0.0/12",
         "192.168.0.0/16",
         "fd00::/8",
-        };
-    public static final int terminalWidth_computer = 51;
-    public static final int terminalHeight_computer = 19;
-    public static final int terminalWidth_turtle = 39;
-    public static final int terminalHeight_turtle = 13;
-    public static final int terminalWidth_pocketComputer = 26;
-    public static final int terminalHeight_pocketComputer = 20;
-    // Registries
-    public static final ClientComputerRegistry clientComputerRegistry = new ClientComputerRegistry();
-    public static final ServerComputerRegistry serverComputerRegistry = new ServerComputerRegistry();
-    // Logging
-    public static final Logger log = LogManager.getLogger(MOD_ID);
-    public static ItemGroup MAIN_GROUP = FabricItemGroupBuilder.build(new Identifier(MOD_ID, "main"), () -> new ItemStack(ModBlocks.COMPUTER_NORMAL));
-    public static List<AddressRule> httpRules = Collections.unmodifiableList(Stream.concat(Stream.of(DEFAULT_HTTP_BLACKLIST)
-                                                                                                 .map(x -> AddressRule.parse(x, Action.DENY.toPartial()))
-                                                                                                 .filter(Objects::nonNull),
-                                                                                           Stream.of(DEFAULT_HTTP_WHITELIST)
-                                                                                                 .map(x -> AddressRule.parse(x, Action.ALLOW.toPartial()))
-                                                                                                 .filter(Objects::nonNull))
-                                                                                   .collect(Collectors.toList()));
-    public static boolean commandRequireCreative = false;
-    public static MonitorRenderer monitorRenderer = MonitorRenderer.BEST;
+    };
+
     public static int computerSpaceLimit = 1000 * 1000;
     public static int floppySpaceLimit = 125 * 1000;
     public static int maximumFilesOpen = 128;
@@ -101,57 +113,552 @@ public final class ComputerCraft implements ModInitializer {
     public static String default_computer_settings = "";
     public static boolean debug_enable = true;
     public static boolean logPeripheralErrors = false;
+
     public static int computer_threads = 1;
-    public static long maxMainGlobalTime = TimeUnit.MILLISECONDS.toNanos(10);
-    public static long maxMainComputerTime = TimeUnit.MILLISECONDS.toNanos(5);
+    public static long maxMainGlobalTime = TimeUnit.MILLISECONDS.toNanos( 10 );
+    public static long maxMainComputerTime = TimeUnit.MILLISECONDS.toNanos( 5 );
+
     public static boolean http_enable = true;
     public static boolean http_websocket_enable = true;
-    public static AddressPredicate http_whitelist = new AddressPredicate(DEFAULT_HTTP_WHITELIST);
-    public static AddressPredicate http_blacklist = new AddressPredicate(DEFAULT_HTTP_BLACKLIST);
+    public static AddressPredicate http_whitelist = new AddressPredicate( DEFAULT_HTTP_WHITELIST );
+    public static AddressPredicate http_blacklist = new AddressPredicate( DEFAULT_HTTP_BLACKLIST );
+
     public static int httpTimeout = 30000;
     public static int httpMaxRequests = 16;
     public static long httpMaxDownload = 16 * 1024 * 1024;
     public static long httpMaxUpload = 4 * 1024 * 1024;
     public static int httpMaxWebsockets = 4;
     public static int httpMaxWebsocketMessage = Websocket.MAX_MESSAGE_SIZE;
+
     public static boolean enableCommandBlock = false;
     public static int modem_range = 64;
     public static int modem_highAltitudeRange = 384;
     public static int modem_rangeDuringStorm = 64;
     public static int modem_highAltitudeRangeDuringStorm = 384;
     public static int maxNotesPerTick = 8;
+
     public static boolean turtlesNeedFuel = true;
     public static int turtleFuelLimit = 20000;
     public static int advancedTurtleFuelLimit = 100000;
     public static boolean turtlesObeyBlockProtection = true;
     public static boolean turtlesCanPush = true;
-    public static EnumSet<TurtleAction> turtleDisabledActions = EnumSet.noneOf(TurtleAction.class);
-    public static int monitorWidth = 8;
-    public static int monitorHeight = 6;
-    public static double monitorDistanceSq = 4096;
+    public static EnumSet<TurtleAction> turtleDisabledActions = EnumSet.noneOf( TurtleAction.class );
 
-    @Override
-    public void onInitialize() {
-        Config.load(Paths.get(FabricLoader.getInstance()
-                                          .getConfigDir()
-                                          .toFile()
-                                          .getPath(), MOD_ID + ".json5"));
-        ComputerCraftProxyCommon.init();
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "colour"), ColourableRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "computer_upgrade"), ComputerUpgradeRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER,
-                          new Identifier(ComputerCraft.MOD_ID, "pocket_computer_upgrade"),
-                          PocketComputerUpgradeRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "disk"), DiskRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "printout"), PrintoutRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "turtle"), TurtleRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "turtle_upgrade"), TurtleUpgradeRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "impostor_shaped"), ImpostorRecipe.SERIALIZER);
-        Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(ComputerCraft.MOD_ID, "impostor_shapeless"), ImpostorShapelessRecipe.SERIALIZER);
-        Registry.register(Registry.LOOT_CONDITION_TYPE, new Identifier(ComputerCraft.MOD_ID, "block_named"), BlockNamedEntityLootCondition.TYPE);
-        Registry.register(Registry.LOOT_CONDITION_TYPE, new Identifier(ComputerCraft.MOD_ID, "player_creative"), PlayerCreativeLootCondition.TYPE);
-        Registry.register(Registry.LOOT_CONDITION_TYPE, new Identifier(ComputerCraft.MOD_ID, "has_id"), HasComputerIdLootCondition.TYPE);
-        init();
+    public static final int terminalWidth_computer = 51;
+    public static final int terminalHeight_computer = 19;
+
+    public static final int terminalWidth_turtle = 39;
+    public static final int terminalHeight_turtle = 13;
+
+    public static final int terminalWidth_pocketComputer = 26;
+    public static final int terminalHeight_pocketComputer = 20;
+
+    // Blocks and Items
+    public static final class Blocks
+    {
+        public static BlockComputer computer;
+        public static BlockCommandComputer commandComputer;
+
+        public static BlockTurtle turtle;
+        public static BlockTurtle turtleExpanded;
+        public static BlockTurtle turtleAdvanced;
+
+        public static BlockPeripheral peripheral;
+        public static BlockCable cable;
+        public static BlockAdvancedModem advancedModem;
+        public static BlockWiredModemFull wiredModemFull;
     }
 
+    public static final class Items
+    {
+        public static ItemComputer computer;
+        public static ItemCommandComputer commandComputer;
+
+        public static ItemTurtleLegacy turtle;
+        public static ItemTurtleNormal turtleExpanded;
+        public static ItemTurtleAdvanced turtleAdvanced;
+
+        public static ItemPocketComputer pocketComputer;
+
+        public static ItemDiskLegacy disk;
+        public static ItemDiskExpanded diskExpanded;
+        public static ItemTreasureDisk treasureDisk;
+
+        public static ItemPrintout printout;
+
+        public static ItemPeripheral peripheral;
+        public static ItemAdvancedModem advancedModem;
+        public static ItemCable cable;
+        public static ItemBlock wiredModemFull;
+    }
+
+    public static final class TurtleUpgrades
+    {
+        public static TurtleModem wirelessModem;
+        public static TurtleModem advancedModem;
+        public static TurtleSpeaker speaker;
+
+        public static TurtleCraftingTable craftingTable;
+        public static TurtleSword diamondSword;
+        public static TurtleShovel diamondShovel;
+        public static TurtleTool diamondPickaxe;
+        public static TurtleAxe diamondAxe;
+        public static TurtleHoe diamondHoe;
+    }
+
+    public static final class PocketUpgrades
+    {
+        public static PocketModem wirelessModem;
+        public static PocketModem advancedModem;
+        public static PocketSpeaker speaker;
+
+        @Deprecated
+        public static PocketSpeaker pocketSpeaker;
+    }
+
+    @Deprecated
+    public static final class Upgrades
+    {
+        public static TurtleModem advancedModem;
+    }
+
+    // Registries
+    public static final ClientComputerRegistry clientComputerRegistry = new ClientComputerRegistry();
+    public static final ServerComputerRegistry serverComputerRegistry = new ServerComputerRegistry();
+
+    // Creative
+    public static CreativeTabMain mainCreativeTab;
+
+    // Logging
+    public static Logger log;
+
+    // Peripheral providers. This is still here to ensure compatibility with Plethora and Computronics
+    public static List<IPeripheralProvider> peripheralProviders = new ArrayList<>();
+
+    // Implementation
+    @Mod.Instance( ComputerCraft.MOD_ID )
+    public static ComputerCraft instance;
+
+    @SidedProxy(
+        clientSide = "dan200.computercraft.client.proxy.ComputerCraftProxyClient",
+        serverSide = "dan200.computercraft.shared.proxy.ComputerCraftProxyCommon"
+    )
+    private static ComputerCraftProxyCommon proxy;
+
+    @Mod.EventHandler
+    public void preInit( FMLPreInitializationEvent event )
+    {
+        log = event.getModLog();
+
+        // Load config
+        Config.load( event.getSuggestedConfigurationFile() );
+
+        proxy.preInit();
+    }
+
+    @Mod.EventHandler
+    public void init( FMLInitializationEvent event )
+    {
+        proxy.init();
+    }
+
+    @Mod.EventHandler
+    public void onServerStarting( FMLServerStartingEvent event )
+    {
+        ComputerCraftProxyCommon.initServer( event.getServer() );
+    }
+
+    @Mod.EventHandler
+    public void onServerStart( FMLServerStartedEvent event )
+    {
+        if( FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER )
+        {
+            ComputerCraft.serverComputerRegistry.reset();
+            WirelessNetwork.resetNetworks();
+            MainThread.reset();
+            Tracking.reset();
+        }
+    }
+
+    @Mod.EventHandler
+    public void onServerStopped( FMLServerStoppedEvent event )
+    {
+        if( FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER )
+        {
+            ComputerCraft.serverComputerRegistry.reset();
+            WirelessNetwork.resetNetworks();
+            MainThread.reset();
+            Tracking.reset();
+        }
+    }
+
+    public static String getVersion()
+    {
+        return VERSION;
+    }
+
+    private static File getBaseDir()
+    {
+        return FMLCommonHandler.instance().getMinecraftServerInstance().getDataDirectory();
+    }
+
+    private static File getResourcePackDir()
+    {
+        return new File( getBaseDir(), "resourcepacks" );
+    }
+
+    @Deprecated
+    public static void registerPermissionProvider( ITurtlePermissionProvider provider )
+    {
+        TurtlePermissions.register( provider );
+    }
+
+    @Deprecated
+    public static void registerPocketUpgrade( IPocketUpgrade upgrade )
+    {
+        dan200.computercraft.shared.PocketUpgrades.register( upgrade );
+    }
+
+    @Deprecated
+    public static void registerPeripheralProvider( IPeripheralProvider provider )
+    {
+        Peripherals.register( provider );
+    }
+
+    @Deprecated
+    public static void registerBundledRedstoneProvider( IBundledRedstoneProvider provider )
+    {
+        BundledRedstone.register( provider );
+    }
+
+    @Deprecated
+    public static void registerMediaProvider( IMediaProvider provider )
+    {
+        MediaProviders.register( provider );
+    }
+
+    @Deprecated
+    public static void registerAPIFactory( ILuaAPIFactory factory )
+    {
+        ApiFactories.register( factory );
+    }
+
+    @Deprecated
+    public static IWiredNode createWiredNodeForElement( IWiredElement element )
+    {
+        return new WiredNode( element );
+    }
+
+    @Deprecated
+    public static IWiredElement getWiredElementAt( IBlockAccess world, BlockPos pos, EnumFacing side )
+    {
+        TileEntity tile = world.getTileEntity( pos );
+        return tile != null && tile.hasCapability( CapabilityWiredElement.CAPABILITY, side )
+            ? tile.getCapability( CapabilityWiredElement.CAPABILITY, side )
+            : null;
+    }
+
+    @Deprecated
+    public static int getDefaultBundledRedstoneOutput( World world, BlockPos pos, EnumFacing side )
+    {
+        return BundledRedstone.getDefaultOutput( world, pos, side );
+    }
+
+    @Deprecated
+    public static IPacketNetwork getWirelessNetwork()
+    {
+        return WirelessNetwork.getUniversal();
+    }
+
+    @Deprecated
+    public static int createUniqueNumberedSaveDir( World world, String parentSubPath )
+    {
+        return IDAssigner.getNextIDFromDirectory( parentSubPath );
+    }
+
+    @Deprecated
+    public static IWritableMount createSaveDirMount( World world, String subPath, long capacity )
+    {
+        try
+        {
+            return new FileMount( new File( getWorldDir(), subPath ), capacity );
+        }
+        catch( Exception e )
+        {
+            return null;
+        }
+    }
+
+    private static void loadFromFile( List<IMount> mounts, File file, String path, boolean allowMissing )
+    {
+        try
+        {
+            if( file.isFile() )
+            {
+                mounts.add( new JarMount( file, path ) );
+            }
+            else
+            {
+                File subResource = new File( file, path );
+                if( subResource.exists() ) mounts.add( new FileMount( subResource, 0 ) );
+            }
+        }
+        catch( IOException | RuntimeException e )
+        {
+            if( allowMissing && e instanceof FileNotFoundException ) return;
+            ComputerCraft.log.error( "Could not load mount '" + path + " 'from '" + file.getName() + "'", e );
+        }
+    }
+
+    @Deprecated
+    public static IMount createResourceMount( Class<?> modClass, String domain, String subPath )
+    {
+        // Start building list of mounts
+        List<IMount> mounts = new ArrayList<>();
+        subPath = "assets/" + domain + "/" + subPath;
+
+        // Mount from debug dir
+        File codeDir = getDebugCodeDir( modClass );
+        if( codeDir != null )
+        {
+            File subResource = new File( codeDir, subPath );
+            if( subResource.exists() )
+            {
+                IMount resourcePackMount = new FileMount( subResource, 0 );
+                mounts.add( resourcePackMount );
+            }
+        }
+
+        // Mount from mod jars, preferring the specified one.
+        File modJar = getContainingJar( modClass );
+        Set<File> otherMods = new HashSet<>();
+        for( ModContainer container : Loader.instance().getActiveModList() )
+        {
+            File modFile = container.getSource();
+            if( modFile != null && !modFile.equals( modJar ) && modFile.exists() )
+            {
+                otherMods.add( container.getSource() );
+            }
+        }
+
+        for( File file : otherMods )
+        {
+            loadFromFile( mounts, file, subPath, true );
+        }
+
+        if( modJar != null )
+        {
+            loadFromFile( mounts, modJar, subPath, false );
+        }
+
+        // Mount from resource packs
+        File resourcePackDir = getResourcePackDir();
+        if( resourcePackDir.exists() && resourcePackDir.isDirectory() )
+        {
+            String[] resourcePacks = resourcePackDir.list();
+            for( String resourcePackName : resourcePacks )
+            {
+                File resourcePack = new File( resourcePackDir, resourcePackName );
+                loadFromFile( mounts, resourcePack, subPath, true );
+            }
+        }
+
+        // Return the combination of all the mounts found
+        if( mounts.size() >= 2 )
+        {
+            IMount[] mountArray = new IMount[mounts.size()];
+            mounts.toArray( mountArray );
+            return new ComboMount( mountArray );
+        }
+        else if( mounts.size() == 1 )
+        {
+            return mounts.get( 0 );
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    public static InputStream getResourceFile( Class<?> modClass, String domain, String subPath )
+    {
+        // Start searching in possible locations
+        subPath = "assets/" + domain + "/" + subPath;
+
+        // Look in resource packs
+        File resourcePackDir = getResourcePackDir();
+        if( resourcePackDir.exists() && resourcePackDir.isDirectory() )
+        {
+            String[] resourcePacks = resourcePackDir.list();
+            for( String resourcePackPath : resourcePacks )
+            {
+                File resourcePack = new File( resourcePackDir, resourcePackPath );
+                if( resourcePack.isDirectory() )
+                {
+                    // Mount a resource pack from a folder
+                    File subResource = new File( resourcePack, subPath );
+                    if( subResource.exists() && subResource.isFile() )
+                    {
+                        try
+                        {
+                            return new FileInputStream( subResource );
+                        }
+                        catch( FileNotFoundException ignored )
+                        {
+                        }
+                    }
+                }
+                else
+                {
+                    ZipFile zipFile = null;
+                    try
+                    {
+                        final ZipFile zip = zipFile = new ZipFile( resourcePack );
+                        ZipEntry entry = zipFile.getEntry( subPath );
+                        if( entry != null )
+                        {
+                            // Return a custom InputStream which will close the original zip when finished.
+                            return new FilterInputStream( zipFile.getInputStream( entry ) )
+                            {
+                                @Override
+                                public void close() throws IOException
+                                {
+                                    super.close();
+                                    zip.close();
+                                }
+                            };
+                        }
+                        else
+                        {
+                            IoUtil.closeQuietly( zipFile );
+                        }
+                    }
+                    catch( IOException e )
+                    {
+                        if( zipFile != null ) IoUtil.closeQuietly( zipFile );
+                    }
+                }
+            }
+        }
+
+        // Look in debug dir
+        File codeDir = getDebugCodeDir( modClass );
+        if( codeDir != null )
+        {
+            File subResource = new File( codeDir, subPath );
+            if( subResource.exists() && subResource.isFile() )
+            {
+                try
+                {
+                    return new FileInputStream( subResource );
+                }
+                catch( FileNotFoundException ignored )
+                {
+                }
+            }
+        }
+
+        // Look in class loader
+        return modClass.getClassLoader().getResourceAsStream( subPath );
+    }
+
+    private static File getContainingJar( Class<?> modClass )
+    {
+        String path = modClass.getProtectionDomain().getCodeSource().getLocation().getPath();
+        int bangIndex = path.indexOf( '!' );
+        if( bangIndex >= 0 )
+        {
+            path = path.substring( 0, bangIndex );
+        }
+
+        URL url;
+        try
+        {
+            url = new URL( path );
+        }
+        catch( MalformedURLException e1 )
+        {
+            return null;
+        }
+
+        File file;
+        try
+        {
+            file = new File( url.toURI() );
+        }
+        catch( URISyntaxException e )
+        {
+            file = new File( url.getPath() );
+        }
+        return file;
+    }
+
+    private static File getDebugCodeDir( Class<?> modClass )
+    {
+        String path = modClass.getProtectionDomain().getCodeSource().getLocation().getPath();
+        int bangIndex = path.indexOf( '!' );
+        return bangIndex >= 0 ? null : new File( new File( path ).getParentFile(), "../.." );
+    }
+
+    @Deprecated
+    public static void registerTurtleUpgrade( ITurtleUpgrade upgrade )
+    {
+        dan200.computercraft.shared.TurtleUpgrades.register( upgrade );
+    }
+
+    public static File getWorldDir()
+    {
+        return DimensionManager.getCurrentSaveRootDirectory();
+    }
+
+    //region Compatibility
+    @Deprecated
+    public static File getWorldDir( World world )
+    {
+        return DimensionManager.getCurrentSaveRootDirectory();
+    }
+
+    @Deprecated
+    public static IMedia getMedia( ItemStack stack )
+    {
+        return MediaProviders.get( stack );
+    }
+
+    @Deprecated
+    public static IPocketUpgrade getPocketUpgrade( ItemStack stack )
+    {
+        return dan200.computercraft.shared.PocketUpgrades.get( stack );
+    }
+
+    @Deprecated
+    public static ITurtleUpgrade getTurtleUpgrade( ItemStack stack )
+    {
+        return dan200.computercraft.shared.TurtleUpgrades.get( stack );
+    }
+
+    @Deprecated
+    public static IPocketUpgrade getPocketUpgrade( String id )
+    {
+        return dan200.computercraft.shared.PocketUpgrades.get( id );
+    }
+
+    @Deprecated
+    public static ITurtleUpgrade getTurtleUpgrade( String id )
+    {
+        return dan200.computercraft.shared.TurtleUpgrades.get( id );
+    }
+
+    @Deprecated
+    public static IPeripheral getPeripheralAt( World world, BlockPos pos, EnumFacing side )
+    {
+        return Peripherals.getPeripheral( world, pos, side );
+    }
+
+    @Deprecated
+    public static boolean canPlayerUseCommands( EntityPlayer player )
+    {
+        MinecraftServer server = player.getServer();
+        return server != null && server.getPlayerList().canSendCommands( player.getGameProfile() );
+    }
+    //endregion
 }

src/main/java/dan200/computercraft/ComputerCraftAPIImpl.java

@@ -1,174 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-
-package dan200.computercraft;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-import dan200.computercraft.api.ComputerCraftAPI.IComputerCraftAPI;
-import dan200.computercraft.api.filesystem.IMount;
-import dan200.computercraft.api.filesystem.IWritableMount;
-import dan200.computercraft.api.lua.ILuaAPIFactory;
-import dan200.computercraft.api.media.IMediaProvider;
-import dan200.computercraft.api.network.IPacketNetwork;
-import dan200.computercraft.api.network.wired.IWiredElement;
-import dan200.computercraft.api.network.wired.IWiredNode;
-import dan200.computercraft.api.peripheral.IPeripheralProvider;
-import dan200.computercraft.api.pocket.IPocketUpgrade;
-import dan200.computercraft.api.redstone.IBundledRedstoneProvider;
-import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.core.apis.ApiFactories;
-import dan200.computercraft.core.filesystem.FileMount;
-import dan200.computercraft.core.filesystem.ResourceMount;
-import dan200.computercraft.mixin.MinecraftServerAccess;
-import dan200.computercraft.shared.BundledRedstone;
-import dan200.computercraft.shared.MediaProviders;
-import dan200.computercraft.shared.Peripherals;
-import dan200.computercraft.shared.PocketUpgrades;
-import dan200.computercraft.shared.TurtleUpgrades;
-import dan200.computercraft.shared.peripheral.modem.wired.TileCable;
-import dan200.computercraft.shared.peripheral.modem.wired.TileWiredModemFull;
-import dan200.computercraft.shared.peripheral.modem.wireless.WirelessNetwork;
-import dan200.computercraft.shared.util.IDAssigner;
-import dan200.computercraft.shared.wired.WiredNode;
-import me.shedaniel.cloth.api.utils.v1.GameInstanceUtils;
-
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.resource.ReloadableResourceManager;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.world.BlockView;
-import net.minecraft.world.World;
-
-import net.fabricmc.loader.api.FabricLoader;
-
-public final class ComputerCraftAPIImpl implements IComputerCraftAPI {
-    public static final ComputerCraftAPIImpl INSTANCE = new ComputerCraftAPIImpl();
-
-    private String version;
-
-    private ComputerCraftAPIImpl() {
-    }
-
-    public static InputStream getResourceFile(String domain, String subPath) {
-        MinecraftServer server = GameInstanceUtils.getServer();
-        if (server != null) {
-            ReloadableResourceManager manager = (ReloadableResourceManager) ((MinecraftServerAccess)server).getServerResourceManager().getResourceManager();
-            try {
-                return manager.getResource(new Identifier(domain, subPath))
-                              .getInputStream();
-            } catch (IOException ignored) {
-                return null;
-            }
-        }
-        return null;
-    }
-
-    @Nonnull
-    @Override
-    public String getInstalledVersion() {
-        if (this.version != null) {
-            return this.version;
-        }
-        return this.version = FabricLoader.getInstance()
-                                          .getModContainer(ComputerCraft.MOD_ID)
-                                          .map(x -> x.getMetadata()
-                                                .getVersion()
-                                                .toString())
-                                          .orElse("unknown");
-    }
-
-    @Override
-    public int createUniqueNumberedSaveDir(@Nonnull World world, @Nonnull String parentSubPath) {
-        return IDAssigner.getNextId(parentSubPath);
-    }
-
-    @Override
-    public IWritableMount createSaveDirMount(@Nonnull World world, @Nonnull String subPath, long capacity) {
-        try {
-            return new FileMount(new File(IDAssigner.getDir(), subPath), capacity);
-        } catch (Exception e) {
-            return null;
-        }
-    }
-
-    @Override
-    public IMount createResourceMount(@Nonnull String domain, @Nonnull String subPath) {
-        MinecraftServer server = GameInstanceUtils.getServer();
-        if (server != null) {
-            ReloadableResourceManager manager = (ReloadableResourceManager) ((MinecraftServerAccess)server).getServerResourceManager().getResourceManager();
-            ResourceMount mount = ResourceMount.get(domain, subPath, manager);
-            return mount.exists("") ? mount : null;
-        }
-        return null;
-    }
-
-    @Override
-    public void registerPeripheralProvider(@Nonnull IPeripheralProvider provider) {
-        Peripherals.register(provider);
-    }
-
-    @Override
-    public void registerTurtleUpgrade(@Nonnull ITurtleUpgrade upgrade) {
-        TurtleUpgrades.register(upgrade);
-    }
-
-    @Override
-    public void registerBundledRedstoneProvider(@Nonnull IBundledRedstoneProvider provider) {
-        BundledRedstone.register(provider);
-    }
-
-    @Override
-    public int getBundledRedstoneOutput(@Nonnull World world, @Nonnull BlockPos pos, @Nonnull Direction side) {
-        return BundledRedstone.getDefaultOutput(world, pos, side);
-    }
-
-    @Override
-    public void registerMediaProvider(@Nonnull IMediaProvider provider) {
-        MediaProviders.register(provider);
-    }
-
-    @Override
-    public void registerPocketUpgrade(@Nonnull IPocketUpgrade upgrade) {
-        PocketUpgrades.register(upgrade);
-    }
-
-    @Nonnull
-    @Override
-    public IPacketNetwork getWirelessNetwork() {
-        return WirelessNetwork.getUniversal();
-    }
-
-    @Override
-    public void registerAPIFactory(@Nonnull ILuaAPIFactory factory) {
-        ApiFactories.register(factory);
-    }
-
-    @Nonnull
-    @Override
-    public IWiredNode createWiredNodeForElement(@Nonnull IWiredElement element) {
-        return new WiredNode(element);
-    }
-
-    @Nullable
-    @Override
-    public IWiredElement getWiredElementAt(@Nonnull BlockView world, @Nonnull BlockPos pos, @Nonnull Direction side) {
-        BlockEntity tile = world.getBlockEntity(pos);
-        if (tile instanceof TileCable) {
-            return ((TileCable) tile).getElement(side);
-        } else if (tile instanceof TileWiredModemFull) {
-            return ((TileWiredModemFull) tile).getElement();
-        }
-        return null;
-    }
-}

src/main/java/dan200/computercraft/api/AbstractTurtleUpgrade.java

@@ -0,0 +1,97 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.ITurtleUpgrade;
+import dan200.computercraft.api.turtle.TurtleUpgradeType;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A base class for {@link ITurtleUpgrade}s.
+ *
+ * One does not have to use this, but it does provide a convenient template.
+ */
+public abstract class AbstractTurtleUpgrade implements ITurtleUpgrade
+{
+    private final ResourceLocation id;
+    private final int legacyId;
+    private final TurtleUpgradeType type;
+    private final String adjective;
+    private final ItemStack stack;
+
+    protected AbstractTurtleUpgrade( ResourceLocation id, int legacyId, TurtleUpgradeType type, String adjective, ItemStack stack )
+    {
+        this.id = id;
+        this.legacyId = legacyId;
+        this.type = type;
+        this.adjective = adjective;
+        this.stack = stack;
+    }
+
+    protected AbstractTurtleUpgrade( ResourceLocation id, int legacyId, TurtleUpgradeType type, String adjective, Item item )
+    {
+        this( id, legacyId, type, adjective, new ItemStack( item ) );
+    }
+
+    protected AbstractTurtleUpgrade( ResourceLocation id, int legacyId, TurtleUpgradeType type, String adjective, Block block )
+    {
+        this( id, legacyId, type, adjective, new ItemStack( block ) );
+    }
+
+    protected AbstractTurtleUpgrade( ResourceLocation id, int legacyId, TurtleUpgradeType type, ItemStack stack )
+    {
+        this( id, legacyId, type, "upgrade." + id + ".adjective", stack );
+    }
+
+    protected AbstractTurtleUpgrade( ResourceLocation id, int legacyId, TurtleUpgradeType type, Item item )
+    {
+        this( id, legacyId, type, new ItemStack( item ) );
+    }
+
+    protected AbstractTurtleUpgrade( ResourceLocation id, int legacyId, TurtleUpgradeType type, Block block )
+    {
+        this( id, legacyId, type, new ItemStack( block ) );
+    }
+
+    @Nonnull
+    @Override
+    public final ResourceLocation getUpgradeID()
+    {
+        return id;
+    }
+
+    @Override
+    public final int getLegacyUpgradeID()
+    {
+        return legacyId;
+    }
+
+    @Nonnull
+    @Override
+    public final String getUnlocalisedAdjective()
+    {
+        return adjective;
+    }
+
+    @Nonnull
+    @Override
+    public final TurtleUpgradeType getType()
+    {
+        return type;
+    }
+
+    @Nonnull
+    @Override
+    public final ItemStack getCraftingItem()
+    {
+        return stack;
+    }
+}

src/main/java/dan200/computercraft/api/ComputerCraftAPI.java

@@ -3,12 +3,8 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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 javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
 import dan200.computercraft.api.filesystem.IMount;
 import dan200.computercraft.api.filesystem.IWritableMount;
 import dan200.computercraft.api.lua.ILuaAPIFactory;
@@ -20,47 +16,55 @@ import dan200.computercraft.api.network.wired.IWiredNode;
 import dan200.computercraft.api.peripheral.IComputerAccess;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.peripheral.IPeripheralProvider;
+import dan200.computercraft.api.permissions.ITurtlePermissionProvider;
 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.redstone.IBundledRedstoneProvider;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.world.BlockView;
+import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.lang.reflect.Method;
+
 /**
  * The static entry point to the ComputerCraft API.
  *
- * Members in this class must be called after mod_ComputerCraft has been initialised, but may be called before it is fully loaded.
+ * Members in this class must be called after mod_ComputerCraft has been initialised, but may be called before it is
+ * fully loaded.
  */
-public final class ComputerCraftAPI {
-    private static IComputerCraftAPI instance;
-
-    @Nonnull
-    @Deprecated
-    public static String getAPIVersion() {
-        return getInstalledVersion();
+public final class ComputerCraftAPI
+{
+    public static boolean isInstalled()
+    {
+        findCC();
+        return computerCraft != null;
     }
 
     @Nonnull
-    public static String getInstalledVersion() {
-        return getInstance().getInstalledVersion();
+    public static String getInstalledVersion()
+    {
+        findCC();
+        if( computerCraft_getVersion != null )
+        {
+            try
+            {
+                return (String) computerCraft_getVersion.invoke( null );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
+        return "";
     }
 
     @Nonnull
-    private static IComputerCraftAPI getInstance() {
-        if (instance != null) {
-            return instance;
-        }
-
-        try {
-            return instance = (IComputerCraftAPI) Class.forName("dan200.computercraft.ComputerCraftAPIImpl")
-                                                       .getField("INSTANCE")
-                                                       .get(null);
-        } catch (ReflectiveOperationException e) {
-            throw new IllegalStateException("Cannot find ComputerCraft API", e);
-        }
+    public static String getAPIVersion()
+    {
+        return "${version}";
     }
 
     /**
@@ -68,29 +72,43 @@ public final class ComputerCraftAPI {
      *
      * Use in conjunction with createSaveDirMount() to create a unique place for your peripherals or media items to store files.
      *
-     * @param world The world for which the save dir should be created. This should be the server side world object.
+     * @param world         The world for which the save dir should be created. This should be the server side world object.
      * @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.
      *
-     *     eg: if createUniqueNumberedSaveDir( world, "computer/disk" ) was called returns 42, then "computer/disk/42" is now available for writing.
+     * eg: if createUniqueNumberedSaveDir( world, "computer/disk" ) was called returns 42, then "computer/disk/42" is now
+     * available for writing.
      * @see #createSaveDirMount(World, String, long)
      */
-    public static int createUniqueNumberedSaveDir(@Nonnull World world, @Nonnull String parentSubPath) {
-        return getInstance().createUniqueNumberedSaveDir(world, parentSubPath);
+    public static int createUniqueNumberedSaveDir( @Nonnull World world, @Nonnull String parentSubPath )
+    {
+        findCC();
+        if( computerCraft_createUniqueNumberedSaveDir != null )
+        {
+            try
+            {
+                return (Integer) computerCraft_createUniqueNumberedSaveDir.invoke( null, world, parentSubPath );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
+        return -1;
     }
 
     /**
      * Creates a file system mount that maps to a subfolder of the save directory for a given world, and returns it.
      *
-     * Use in conjunction with IComputerAccess.mount() or IComputerAccess.mountWritable() to mount a folder from the users save directory onto a computers
-     * file system.
+     * Use in conjunction with IComputerAccess.mount() or IComputerAccess.mountWritable() to mount a folder from the
+     * users save directory onto a computers file system.
      *
-     * @param world The world for which the save dir can be found. This should be the server side world object.
-     * @param subPath The folder path within the save directory that the mount should map to. eg: "computer/disk/42". Use createUniqueNumberedSaveDir()
-     *     to create a new numbered folder to use.
+     * @param world    The world for which the save dir can be found. This should be the server side world object.
+     * @param subPath  The folder path within the save directory that the mount should map to. eg: "computer/disk/42".
+     *                 Use createUniqueNumberedSaveDir() 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 mount, or null if it could be created for some reason. Use IComputerAccess.mount() or IComputerAccess.mountWritable() to mount this on a
-     *     Computers' file system.
+     * @return The mount, or null if it could be created for some reason. Use IComputerAccess.mount() or IComputerAccess.mountWritable()
+     * to mount this on a Computers' file system.
      * @see #createUniqueNumberedSaveDir(World, String)
      * @see IComputerAccess#mount(String, IMount)
      * @see IComputerAccess#mountWritable(String, IWritableMount)
@@ -98,28 +116,57 @@ public final class ComputerCraftAPI {
      * @see IWritableMount
      */
     @Nullable
-    public static IWritableMount createSaveDirMount(@Nonnull World world, @Nonnull String subPath, long capacity) {
-        return getInstance().createSaveDirMount(world, subPath, capacity);
+    public static IWritableMount createSaveDirMount( @Nonnull World world, @Nonnull String subPath, long capacity )
+    {
+        findCC();
+        if( computerCraft_createSaveDirMount != null )
+        {
+            try
+            {
+                return (IWritableMount) computerCraft_createSaveDirMount.invoke( null, world, subPath, capacity );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
+        return null;
     }
 
     /**
      * Creates a file system mount to a resource folder, and returns it.
      *
-     * Use in conjunction with {@link IComputerAccess#mount} or {@link IComputerAccess#mountWritable} to mount a resource folder onto a computer's file
-     * system.
+     * Use in conjunction with IComputerAccess.mount() or IComputerAccess.mountWritable() to mount a resource folder
+     * onto a computer's file system.
      *
-     * 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.
+     * The files in this mount will be a combination of files in the specified mod jar, and resource packs that contain
+     * resources with the same domain and path.
      *
-     * @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.
+     * @param modClass A class in whose jar to look first for the resources to mount. Using your main mod class is recommended. eg: MyMod.class
+     * @param domain   The domain under which to look for resources. eg: "mymod".
+     * @param subPath  The domain under which to look for resources. eg: "mymod/lua/myfiles".
+     * @return The mount, or {@code null} if it could be created for some reason. Use IComputerAccess.mount() or
+     * IComputerAccess.mountWritable() to mount this on a Computers' file system.
      * @see IComputerAccess#mount(String, IMount)
      * @see IComputerAccess#mountWritable(String, IWritableMount)
      * @see IMount
      */
     @Nullable
-    public static IMount createResourceMount(@Nonnull String domain, @Nonnull String subPath) {
-        return getInstance().createResourceMount(domain, subPath);
+    public static IMount createResourceMount( @Nonnull Class<?> modClass, @Nonnull String domain, @Nonnull String subPath )
+    {
+        findCC();
+        if( computerCraft_createResourceMount != null )
+        {
+            try
+            {
+                return (IMount) computerCraft_createResourceMount.invoke( null, modClass, domain, subPath );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
+        return null;
     }
 
     /**
@@ -129,19 +176,47 @@ public final class ComputerCraftAPI {
      * @see IPeripheral
      * @see IPeripheralProvider
      */
-    public static void registerPeripheralProvider(@Nonnull IPeripheralProvider provider) {
-        getInstance().registerPeripheralProvider(provider);
+    public static void registerPeripheralProvider( @Nonnull IPeripheralProvider provider )
+    {
+        findCC();
+        if( computerCraft_registerPeripheralProvider != null )
+        {
+            try
+            {
+                computerCraft_registerPeripheralProvider.invoke( null, provider );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
     }
 
     /**
-     * Registers a new turtle turtle for use in ComputerCraft. After calling this, users should be able to craft Turtles with your new turtle. It is
-     * recommended to call this during the load() method of your mod.
+     * Registers a new turtle turtle for use in ComputerCraft. After calling this,
+     * users should be able to craft Turtles with your new turtle. It is recommended to call
+     * this during the load() method of your mod.
      *
      * @param upgrade The turtle upgrade to register.
      * @see ITurtleUpgrade
      */
-    public static void registerTurtleUpgrade(@Nonnull ITurtleUpgrade upgrade) {
-        getInstance().registerTurtleUpgrade(upgrade);
+    public static void registerTurtleUpgrade( @Nonnull ITurtleUpgrade upgrade )
+    {
+        if( upgrade != null )
+        {
+            findCC();
+            if( computerCraft_registerTurtleUpgrade != null )
+            {
+                try
+                {
+                    computerCraft_registerTurtleUpgrade.invoke( null, upgrade );
+                }
+                catch( Exception e )
+                {
+                    // It failed
+                }
+            }
+        }
     }
 
     /**
@@ -150,22 +225,47 @@ public final class ComputerCraftAPI {
      * @param provider The bundled redstone provider to register.
      * @see IBundledRedstoneProvider
      */
-    public static void registerBundledRedstoneProvider(@Nonnull IBundledRedstoneProvider provider) {
-        getInstance().registerBundledRedstoneProvider(provider);
+    public static void registerBundledRedstoneProvider( @Nonnull IBundledRedstoneProvider provider )
+    {
+        findCC();
+        if( computerCraft_registerBundledRedstoneProvider != null )
+        {
+            try
+            {
+                computerCraft_registerBundledRedstoneProvider.invoke( null, provider );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
     }
 
     /**
      * 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.
+     * @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 IBundledRedstoneProvider
      */
-    public static int getBundledRedstoneOutput(@Nonnull World world, @Nonnull BlockPos pos, @Nonnull Direction side) {
-        return getInstance().getBundledRedstoneOutput(world, pos, side);
+    public static int getBundledRedstoneOutput( @Nonnull World world, @Nonnull BlockPos pos, @Nonnull EnumFacing side )
+    {
+        findCC();
+        if( computerCraft_getDefaultBundledRedstoneOutput != null )
+        {
+            try
+            {
+                return (Integer) computerCraft_getDefaultBundledRedstoneOutput.invoke( null, world, pos, side );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
+        return -1;
     }
 
     /**
@@ -174,12 +274,60 @@ public final class ComputerCraftAPI {
      * @param provider The media provider to register.
      * @see IMediaProvider
      */
-    public static void registerMediaProvider(@Nonnull IMediaProvider provider) {
-        getInstance().registerMediaProvider(provider);
+    public static void registerMediaProvider( @Nonnull IMediaProvider provider )
+    {
+        findCC();
+        if( computerCraft_registerMediaProvider != null )
+        {
+            try
+            {
+                computerCraft_registerMediaProvider.invoke( null, provider );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
     }
 
-    public static void registerPocketUpgrade(@Nonnull IPocketUpgrade upgrade) {
-        getInstance().registerPocketUpgrade(upgrade);
+    /**
+     * Registers a permission provider to restrict where turtles can move or build.
+     *
+     * @param provider The turtle permission provider to register.
+     * @see ITurtlePermissionProvider
+     * @deprecated Prefer using {@link dan200.computercraft.api.turtle.event.TurtleBlockEvent} or the standard Forge events.
+     */
+    @Deprecated
+    public static void registerPermissionProvider( @Nonnull ITurtlePermissionProvider provider )
+    {
+        findCC();
+        if( computerCraft_registerPermissionProvider != null )
+        {
+            try
+            {
+                computerCraft_registerPermissionProvider.invoke( null, provider );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
+    }
+
+    public static void registerPocketUpgrade( @Nonnull IPocketUpgrade upgrade )
+    {
+        findCC();
+        if( computerCraft_registerPocketUpgrade != null )
+        {
+            try
+            {
+                computerCraft_registerPocketUpgrade.invoke( null, upgrade );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
     }
 
     /**
@@ -187,12 +335,38 @@ public final class ComputerCraftAPI {
      *
      * @return The global wireless network, or {@code null} if it could not be fetched.
      */
-    public static IPacketNetwork getWirelessNetwork() {
-        return getInstance().getWirelessNetwork();
+    public static IPacketNetwork getWirelessNetwork()
+    {
+        findCC();
+        if( computerCraft_getWirelessNetwork != null )
+        {
+            try
+            {
+                return (IPacketNetwork) computerCraft_getWirelessNetwork.invoke( null );
+            }
+            catch( Exception e )
+            {
+                // It failed;
+            }
+        }
+
+        return null;
     }
 
-    public static void registerAPIFactory(@Nonnull ILuaAPIFactory factory) {
-        getInstance().registerAPIFactory(factory);
+    public static void registerAPIFactory( @Nonnull ILuaAPIFactory upgrade )
+    {
+        findCC();
+        if( computerCraft_registerAPIFactory != null )
+        {
+            try
+            {
+                computerCraft_registerAPIFactory.invoke( null, upgrade );
+            }
+            catch( Exception e )
+            {
+                // It failed
+            }
+        }
     }
 
     /**
@@ -203,57 +377,147 @@ public final class ComputerCraftAPI {
      * @see IWiredElement#getNode()
      */
     @Nonnull
-    public static IWiredNode createWiredNodeForElement(@Nonnull IWiredElement element) {
-        return getInstance().createWiredNodeForElement(element);
+    public static IWiredNode createWiredNodeForElement( @Nonnull IWiredElement element )
+    {
+        findCC();
+        if( computerCraft_createWiredNodeForElement != null )
+        {
+            try
+            {
+                return (IWiredNode) computerCraft_createWiredNodeForElement.invoke( null, element );
+            }
+            catch( ReflectiveOperationException e )
+            {
+                throw new IllegalStateException( "Error creating wired node", e );
+            }
+        }
+        else
+        {
+            throw new IllegalStateException( "ComputerCraft cannot be found" );
+        }
     }
 
     /**
      * Get the wired network element for a block in world.
      *
      * @param world The world the block exists in
-     * @param pos The position the block exists in
-     * @param side The side to extract the network element from
+     * @param pos   The position the block exists in
+     * @param side  The side to extract the network element from
      * @return The element's node
      * @see IWiredElement#getNode()
      */
     @Nullable
-    public static IWiredElement getWiredElementAt(@Nonnull BlockView world, @Nonnull BlockPos pos, @Nonnull Direction side) {
-        return getInstance().getWiredElementAt(world, pos, side);
+    public static IWiredElement getWiredElementAt( @Nonnull IBlockAccess world, @Nonnull BlockPos pos, @Nonnull EnumFacing side )
+    {
+        findCC();
+        if( computerCraft_getWiredElementAt != null )
+        {
+            try
+            {
+                return (IWiredElement) computerCraft_getWiredElementAt.invoke( null, world, pos, side );
+            }
+            catch( ReflectiveOperationException ignored )
+            {
+            }
+        }
+
+        return null;
     }
 
-    public interface IComputerCraftAPI {
-        @Nonnull
-        String getInstalledVersion();
+    // The functions below here are private, and are used to interface with the non-API ComputerCraft classes.
+    // Reflection is used here so you can develop your mod without decompiling ComputerCraft and including
+    // it in your solution, and so your mod won't crash if ComputerCraft is installed.
 
-        int createUniqueNumberedSaveDir(@Nonnull World world, @Nonnull String parentSubPath);
-
-        @Nullable
-        IWritableMount createSaveDirMount(@Nonnull World world, @Nonnull String subPath, long capacity);
-
-        @Nullable
-        IMount createResourceMount(@Nonnull String domain, @Nonnull String subPath);
-
-        void registerPeripheralProvider(@Nonnull IPeripheralProvider provider);
-
-        void registerTurtleUpgrade(@Nonnull ITurtleUpgrade upgrade);
-
-        void registerBundledRedstoneProvider(@Nonnull IBundledRedstoneProvider provider);
-
-        int getBundledRedstoneOutput(@Nonnull World world, @Nonnull BlockPos pos, @Nonnull Direction side);
-
-        void registerMediaProvider(@Nonnull IMediaProvider provider);
-
-        void registerPocketUpgrade(@Nonnull IPocketUpgrade upgrade);
-
-        @Nonnull
-        IPacketNetwork getWirelessNetwork();
-
-        void registerAPIFactory(@Nonnull ILuaAPIFactory factory);
-
-        @Nonnull
-        IWiredNode createWiredNodeForElement(@Nonnull IWiredElement element);
-
-        @Nullable
-        IWiredElement getWiredElementAt(@Nonnull BlockView world, @Nonnull BlockPos pos, @Nonnull Direction side);
+    private static void findCC()
+    {
+        if( !ccSearched )
+        {
+            try
+            {
+                computerCraft = Class.forName( "dan200.computercraft.ComputerCraft" );
+                computerCraft_getVersion = findCCMethod( "getVersion", new Class<?>[] {
+                } );
+                computerCraft_createUniqueNumberedSaveDir = findCCMethod( "createUniqueNumberedSaveDir", new Class<?>[] {
+                    World.class, String.class,
+                } );
+                computerCraft_createSaveDirMount = findCCMethod( "createSaveDirMount", new Class<?>[] {
+                    World.class, String.class, Long.TYPE,
+                } );
+                computerCraft_createResourceMount = findCCMethod( "createResourceMount", new Class<?>[] {
+                    Class.class, String.class, String.class,
+                } );
+                computerCraft_registerPeripheralProvider = findCCMethod( "registerPeripheralProvider", new Class<?>[] {
+                    IPeripheralProvider.class,
+                } );
+                computerCraft_registerTurtleUpgrade = findCCMethod( "registerTurtleUpgrade", new Class<?>[] {
+                    ITurtleUpgrade.class,
+                } );
+                computerCraft_registerBundledRedstoneProvider = findCCMethod( "registerBundledRedstoneProvider", new Class<?>[] {
+                    IBundledRedstoneProvider.class,
+                } );
+                computerCraft_getDefaultBundledRedstoneOutput = findCCMethod( "getDefaultBundledRedstoneOutput", new Class<?>[] {
+                    World.class, BlockPos.class, EnumFacing.class,
+                } );
+                computerCraft_registerMediaProvider = findCCMethod( "registerMediaProvider", new Class<?>[] {
+                    IMediaProvider.class,
+                } );
+                computerCraft_registerPermissionProvider = findCCMethod( "registerPermissionProvider", new Class<?>[] {
+                    ITurtlePermissionProvider.class,
+                } );
+                computerCraft_registerPocketUpgrade = findCCMethod( "registerPocketUpgrade", new Class<?>[] {
+                    IPocketUpgrade.class,
+                } );
+                computerCraft_getWirelessNetwork = findCCMethod( "getWirelessNetwork", new Class<?>[] {
+                } );
+                computerCraft_registerAPIFactory = findCCMethod( "registerAPIFactory", new Class<?>[] {
+                    ILuaAPIFactory.class,
+                } );
+                computerCraft_createWiredNodeForElement = findCCMethod( "createWiredNodeForElement", new Class<?>[] {
+                    IWiredElement.class,
+                } );
+                computerCraft_getWiredElementAt = findCCMethod( "getWiredElementAt", new Class<?>[] {
+                    IBlockAccess.class, BlockPos.class, EnumFacing.class,
+                } );
+            }
+            catch( Exception e )
+            {
+                System.err.println( "ComputerCraftAPI: ComputerCraft not found." );
+            }
+            finally
+            {
+                ccSearched = true;
+            }
+        }
     }
+
+    private static Method findCCMethod( String name, Class<?>[] args )
+    {
+        try
+        {
+            return computerCraft != null ? computerCraft.getMethod( name, args ) : null;
+        }
+        catch( NoSuchMethodException e )
+        {
+            System.err.println( "ComputerCraftAPI: ComputerCraft method " + name + " not found." );
+            return null;
+        }
+    }
+
+    private static boolean ccSearched = false;
+    private static Class<?> computerCraft = null;
+    private static Method computerCraft_getVersion = null;
+    private static Method computerCraft_createUniqueNumberedSaveDir = null;
+    private static Method computerCraft_createSaveDirMount = null;
+    private static Method computerCraft_createResourceMount = null;
+    private static Method computerCraft_registerPeripheralProvider = null;
+    private static Method computerCraft_registerTurtleUpgrade = null;
+    private static Method computerCraft_registerBundledRedstoneProvider = null;
+    private static Method computerCraft_getDefaultBundledRedstoneOutput = null;
+    private static Method computerCraft_registerMediaProvider = null;
+    private static Method computerCraft_registerPermissionProvider = null;
+    private static Method computerCraft_registerPocketUpgrade = null;
+    private static Method computerCraft_getWirelessNetwork = null;
+    private static Method computerCraft_registerAPIFactory = null;
+    private static Method computerCraft_createWiredNodeForElement = null;
+    private static Method computerCraft_getWiredElementAt = null;
 }

src/main/java/dan200/computercraft/api/client/TransformedModel.java

@@ -1,83 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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 java.util.Objects;
-
-import javax.annotation.Nonnull;
-
-import dan200.computercraft.mixin.AffineTransformationAccess;
-
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.render.model.BakedModelManager;
-import net.minecraft.client.util.ModelIdentifier;
-import net.minecraft.client.util.math.AffineTransformation;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.item.ItemStack;
-
-import net.fabricmc.api.EnvType;
-import net.fabricmc.api.Environment;
-
-/**
- * A model to render, combined with a transformation matrix to apply.
- */
-@Environment (EnvType.CLIENT)
-public final class TransformedModel {
-    private final BakedModel model;
-    private final AffineTransformation matrix;
-
-    public TransformedModel(@Nonnull BakedModel model, @Nonnull AffineTransformation matrix) {
-        this.model = Objects.requireNonNull(model);
-        this.matrix = Objects.requireNonNull(matrix);
-    }
-
-    public TransformedModel(@Nonnull BakedModel model) {
-        this.model = Objects.requireNonNull(model);
-        this.matrix = AffineTransformation.identity();
-    }
-
-    public static TransformedModel of(@Nonnull ModelIdentifier location) {
-        BakedModelManager modelManager = MinecraftClient.getInstance()
-                                                        .getBakedModelManager();
-        return new TransformedModel(modelManager.getModel(location));
-    }
-
-    public static TransformedModel of(@Nonnull ItemStack item, @Nonnull AffineTransformation transform) {
-        BakedModel model = MinecraftClient.getInstance()
-                                          .getItemRenderer()
-                                          .getModels()
-                                          .getModel(item);
-        return new TransformedModel(model, transform);
-    }
-
-    @Nonnull
-    public BakedModel getModel() {
-        return this.model;
-    }
-
-    @Nonnull
-    public AffineTransformation getMatrix() {
-        return this.matrix;
-    }
-
-    public void push(MatrixStack matrixStack) {
-        matrixStack.push();
-
-        AffineTransformationAccess access = (AffineTransformationAccess) (Object) this.matrix;
-        if (access.getTranslation() != null)
-            matrixStack.translate(access.getTranslation().getX(), access.getTranslation().getY(), access.getTranslation().getZ());
-
-        matrixStack.multiply(this.matrix.getRotation2());
-
-        if (access.getScale() != null)
-            matrixStack.scale(access.getScale().getX(), access.getScale().getY(), access.getScale().getZ());
-
-        if (access.getRotation1() != null)
-            matrixStack.multiply(access.getRotation1());
-    }
-}

src/main/java/dan200/computercraft/api/filesystem/FileAttributes.java

@@ -1,71 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.filesystem;
-
-import java.nio.file.attribute.BasicFileAttributes;
-import java.nio.file.attribute.FileTime;
-import java.time.Instant;
-
-/**
- * A simple version of {@link BasicFileAttributes}, which provides what information a {@link IMount} already exposes.
- */
-final class FileAttributes implements BasicFileAttributes {
-    private static final FileTime EPOCH = FileTime.from(Instant.EPOCH);
-
-    private final boolean isDirectory;
-    private final long size;
-
-    FileAttributes(boolean isDirectory, long size) {
-        this.isDirectory = isDirectory;
-        this.size = size;
-    }
-
-    @Override
-    public FileTime lastModifiedTime() {
-        return EPOCH;
-    }
-
-    @Override
-    public FileTime lastAccessTime() {
-        return EPOCH;
-    }
-
-    @Override
-    public FileTime creationTime() {
-        return EPOCH;
-    }
-
-    @Override
-    public boolean isRegularFile() {
-        return !this.isDirectory;
-    }
-
-    @Override
-    public boolean isDirectory() {
-        return this.isDirectory;
-    }
-
-    @Override
-    public boolean isSymbolicLink() {
-        return false;
-    }
-
-    @Override
-    public boolean isOther() {
-        return false;
-    }
-
-    @Override
-    public long size() {
-        return this.size;
-    }
-
-    @Override
-    public Object fileKey() {
-        return null;
-    }
-}

src/main/java/dan200/computercraft/api/filesystem/FileOperationException.java

@@ -3,37 +3,39 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.filesystem;
 
-import java.io.IOException;
-import java.util.Objects;
-
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import java.io.IOException;
+import java.util.Objects;
 
 /**
  * An {@link IOException} which occurred on a specific file.
  *
  * This may be thrown from a {@link IMount} or {@link IWritableMount} to give more information about a failure.
  */
-public class FileOperationException extends IOException {
+public class FileOperationException extends IOException
+{
     private static final long serialVersionUID = -8809108200853029849L;
 
     private final String filename;
 
-    public FileOperationException(@Nullable String filename, @Nonnull String message) {
-        super(Objects.requireNonNull(message, "message cannot be null"));
+    public FileOperationException( @Nullable String filename, @Nonnull String message )
+    {
+        super( Objects.requireNonNull( message, "message cannot be null" ) );
         this.filename = filename;
     }
 
-    public FileOperationException(@Nonnull String message) {
-        super(Objects.requireNonNull(message, "message cannot be null"));
+    public FileOperationException( String message )
+    {
+        super( Objects.requireNonNull( message, "message cannot be null" ) );
         this.filename = null;
     }
 
     @Nullable
-    public String getFilename() {
-        return this.filename;
+    public String getFilename()
+    {
+        return filename;
     }
 }

src/main/java/dan200/computercraft/api/filesystem/IFileSystem.java

@@ -3,7 +3,6 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.filesystem;
 
 import java.io.IOException;
@@ -13,31 +12,32 @@ import java.io.IOException;
  *
  * This exists for use by various APIs - one should not attempt to mount it.
  */
-public interface IFileSystem extends IWritableMount {
+public interface IFileSystem extends IWritableMount
+{
     /**
      * Combine two paths together, reducing them into a normalised form.
      *
-     * @param path The main path.
+     * @param path  The main path.
      * @param child The path to append.
      * @return The combined, normalised path.
      */
-    String combine(String path, String child);
+    String combine( String path, String child );
 
     /**
      * Copy files from one location to another.
      *
      * @param from The location to copy from.
-     * @param to The location to copy to. This should not exist.
+     * @param to   The location to copy to. This should not exist.
      * @throws IOException If the copy failed.
      */
-    void copy(String from, String to) throws IOException;
+    void copy( String from, String to ) throws IOException;
 
     /**
      * Move files from one location to another.
      *
      * @param from The location to move from.
-     * @param to The location to move to. This should not exist.
+     * @param to   The location to move to. This should not exist.
      * @throws IOException If the move failed.
      */
-    void move(String from, String to) throws IOException;
+    void move( String from, String to ) throws IOException;
 }

src/main/java/dan200/computercraft/api/filesystem/IMount.java

@@ -3,68 +3,34 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.filesystem;
 
-import java.io.IOException;
-import java.nio.channels.ReadableByteChannel;
-import java.nio.file.attribute.BasicFileAttributes;
-import java.util.List;
-
-import javax.annotation.Nonnull;
-
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IComputerAccess;
-
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import java.util.List;
+
 /**
- * Represents a read only part of a virtual filesystem that can be mounted onto a computer using {@link IComputerAccess#mount(String, IMount)}.
+ * Represents a read only part of a virtual filesystem that can be mounted onto a computer using
+ * {@link IComputerAccess#mount(String, IMount)}.
  *
- * Ready made implementations of this interface can be created using {@link ComputerCraftAPI#createSaveDirMount(World, String, long)} or {@link
- * ComputerCraftAPI#createResourceMount(String, String)}, or you're free to implement it yourselves!
+ * Ready made implementations of this interface can be created using
+ * {@link ComputerCraftAPI#createSaveDirMount(World, String, long)} or
+ * {@link ComputerCraftAPI#createResourceMount(Class, String, String)}, or you're free to implement it yourselves!
  *
  * @see ComputerCraftAPI#createSaveDirMount(World, String, long)
- * @see ComputerCraftAPI#createResourceMount(String, String)
+ * @see ComputerCraftAPI#createResourceMount(Class, String, String)
  * @see IComputerAccess#mount(String, IMount)
  * @see IWritableMount
  */
-public interface IMount {
-    /**
-     * Returns the file names of all the files in a directory.
-     *
-     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprograms".
-     * @param contents A list of strings. Add all the file names to this list.
-     * @throws IOException If the file was not a directory, or could not be listed.
-     */
-    void list(@Nonnull String path, @Nonnull List<String> contents) throws IOException;
-
-    /**
-     * Opens a file with a given path, and returns an {@link ReadableByteChannel} representing its contents.
-     *
-     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
-     * @return A channel representing the contents of the file. If the channel implements {@link java.nio.channels.SeekableByteChannel}, one will be able to
-     *     seek to arbitrary positions when using binary mode.
-     * @throws IOException If the file does not exist, or could not be opened.
-     */
-    @Nonnull
-    ReadableByteChannel openForRead(@Nonnull String path) throws IOException;
-
-    /**
-     * Get attributes about the given file.
-     *
-     * @param path The path to query.
-     * @return File attributes for the given file.
-     * @throws IOException If the file does not exist, or attributes could not be fetched.
-     */
-    @Nonnull
-    default BasicFileAttributes getAttributes(@Nonnull String path) throws IOException {
-        if (!this.exists(path)) {
-            throw new FileOperationException(path, "No such file");
-        }
-        return new FileAttributes(this.isDirectory(path), this.getSize(path));
-    }
-
+public interface IMount
+{
     /**
      * Returns whether a file with a given path exists or not.
      *
@@ -72,7 +38,7 @@ public interface IMount {
      * @return If the file exists.
      * @throws IOException If an error occurs when checking the existence of the file.
      */
-    boolean exists(@Nonnull String path) throws IOException;
+    boolean exists( @Nonnull String path ) throws IOException;
 
     /**
      * Returns whether a file with a given path is a directory or not.
@@ -81,7 +47,16 @@ public interface IMount {
      * @return If the file exists and is a directory
      * @throws IOException If an error occurs when checking whether the file is a directory.
      */
-    boolean isDirectory(@Nonnull String path) throws IOException;
+    boolean isDirectory( @Nonnull String path ) throws IOException;
+
+    /**
+     * Returns the file names of all the files in a directory.
+     *
+     * @param path     A file path in normalised format, relative to the mount location. ie: "programs/myprograms".
+     * @param contents A list of strings. Add all the file names to this list.
+     * @throws IOException If the file was not a directory, or could not be listed.
+     */
+    void list( @Nonnull String path, @Nonnull List<String> contents ) throws IOException;
 
     /**
      * Returns the size of a file with a given path, in bytes.
@@ -90,5 +65,32 @@ public interface IMount {
      * @return The size of the file, in bytes.
      * @throws IOException If the file does not exist, or its size could not be determined.
      */
-    long getSize(@Nonnull String path) throws IOException;
+    long getSize( @Nonnull String path ) throws IOException;
+
+    /**
+     * Opens a file with a given path, and returns an {@link InputStream} representing its contents.
+     *
+     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
+     * @return A stream representing the contents of the file.
+     * @throws IOException If the file does not exist, or could not be opened.
+     * @deprecated Use {@link #openChannelForRead(String)} instead
+     */
+    @Nonnull
+    @Deprecated
+    InputStream openForRead( @Nonnull String path ) throws IOException;
+
+    /**
+     * Opens a file with a given path, and returns an {@link ReadableByteChannel} representing its contents.
+     *
+     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
+     * @return A channel representing the contents of the file. If the channel implements
+     * {@link java.nio.channels.SeekableByteChannel}, one will be able to seek to arbitrary positions when using binary
+     * mode.
+     * @throws IOException If the file does not exist, or could not be opened.
+     */
+    @Nonnull
+    default ReadableByteChannel openChannelForRead( @Nonnull String path ) throws IOException
+    {
+        return Channels.newChannel( openForRead( path ) );
+    }
 }

src/main/java/dan200/computercraft/api/filesystem/IWritableMount.java

@@ -3,41 +3,39 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.filesystem;
 
-import java.io.IOException;
-import java.io.OutputStream;
-import java.nio.channels.WritableByteChannel;
-import java.util.OptionalLong;
-
-import javax.annotation.Nonnull;
-
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IComputerAccess;
-
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
+
 /**
- * Represents a part of a virtual filesystem that can be mounted onto a computer using {@link IComputerAccess#mount(String, IMount)} or {@link
- * IComputerAccess#mountWritable(String, IWritableMount)}, that can also be written to.
+ * Represents a part of a virtual filesystem that can be mounted onto a computer using {@link IComputerAccess#mount(String, IMount)}
+ * or {@link IComputerAccess#mountWritable(String, IWritableMount)}, that can also be written to.
  *
- * Ready made implementations of this interface can be created using {@link ComputerCraftAPI#createSaveDirMount(World, String, long)}, or you're free to
- * implement it yourselves!
+ * Ready made implementations of this interface can be created using
+ * {@link ComputerCraftAPI#createSaveDirMount(World, String, long)}, or you're free to implement it yourselves!
  *
  * @see ComputerCraftAPI#createSaveDirMount(World, String, long)
  * @see IComputerAccess#mount(String, IMount)
  * @see IComputerAccess#mountWritable(String, IWritableMount)
  * @see IMount
  */
-public interface IWritableMount extends IMount {
+public interface IWritableMount extends IMount
+{
     /**
      * Creates a directory at a given path inside the virtual file system.
      *
      * @param path A file path in normalised format, relative to the mount location. ie: "programs/mynewprograms".
      * @throws IOException If the directory already exists or could not be created.
      */
-    void makeDirectory(@Nonnull String path) throws IOException;
+    void makeDirectory( @Nonnull String path ) throws IOException;
 
     /**
      * Deletes a directory at a given path inside the virtual file system.
@@ -45,46 +43,66 @@ public interface IWritableMount extends IMount {
      * @param path A file path in normalised format, relative to the mount location. ie: "programs/myoldprograms".
      * @throws IOException If the file does not exist or could not be deleted.
      */
-    void delete(@Nonnull String path) throws IOException;
+    void delete( @Nonnull String path ) throws IOException;
 
     /**
      * Opens a file with a given path, and returns an {@link OutputStream} for writing to it.
      *
      * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
-     * @return A stream for writing to. If the channel implements {@link java.nio.channels.SeekableByteChannel}, one will be able to seek to arbitrary
-     *     positions when using binary mode.
+     * @return A stream for writing to
+     * @throws IOException If the file could not be opened for writing.
+     * @deprecated Use {@link #openChannelForWrite(String)} instead.
+     */
+    @Nonnull
+    @Deprecated
+    OutputStream openForWrite( @Nonnull String path ) throws IOException;
+
+    /**
+     * Opens a file with a given path, and returns an {@link OutputStream} for writing to it.
+     *
+     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
+     * @return A stream for writing to. If the channel implements {@link java.nio.channels.SeekableByteChannel}, one
+     * will be able to seek to arbitrary positions when using binary mode.
      * @throws IOException If the file could not be opened for writing.
      */
     @Nonnull
-    WritableByteChannel openForWrite(@Nonnull String path) throws IOException;
+    default WritableByteChannel openChannelForWrite( @Nonnull String path ) throws IOException
+    {
+        return Channels.newChannel( openForWrite( path ) );
+    }
 
     /**
      * Opens a file with a given path, and returns an {@link OutputStream} for appending to it.
      *
      * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
-     * @return A stream for writing to. If the channel implements {@link java.nio.channels.SeekableByteChannel}, one will be able to seek to arbitrary
-     *     positions when using binary mode.
+     * @return A stream for writing to.
+     * @throws IOException If the file could not be opened for writing.
+     * @deprecated Use {@link #openChannelForAppend(String)} instead.
+     */
+    @Nonnull
+    @Deprecated
+    OutputStream openForAppend( @Nonnull String path ) throws IOException;
+
+    /**
+     * Opens a file with a given path, and returns an {@link OutputStream} for appending to it.
+     *
+     * @param path A file path in normalised format, relative to the mount location. ie: "programs/myprogram".
+     * @return A stream for writing to. If the channel implements {@link java.nio.channels.SeekableByteChannel}, one
+     * will be able to seek to arbitrary positions when using binary mode.
      * @throws IOException If the file could not be opened for writing.
      */
     @Nonnull
-    WritableByteChannel openForAppend(@Nonnull String path) throws IOException;
+    default WritableByteChannel openChannelForAppend( @Nonnull String path ) throws IOException
+    {
+        return Channels.newChannel( openForAppend( path ) );
+    }
 
     /**
-     * Get the amount of free space on the mount, in bytes. You should decrease this value as the user writes to the mount, and write operations should fail
-     * once it reaches zero.
+     * Get the amount of free space on the mount, in bytes. You should decrease this value as the user writes to the
+     * mount, and write operations should fail once it reaches zero.
      *
      * @return The amount of free space, in bytes.
      * @throws IOException If the remaining space could not be computed.
      */
     long getRemainingSpace() throws IOException;
-
-    /**
-     * Get the capacity of this mount. This should be equal to the size of all files/directories on this mount, minus the {@link #getRemainingSpace()}.
-     *
-     * @return The capacity of this mount, in bytes.
-     */
-    @Nonnull
-    default OptionalLong getCapacity() {
-        return OptionalLong.empty();
-    }
 }

src/main/java/dan200/computercraft/api/filesystem/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|FileSystem", apiVersion = "${version}" )
+package dan200.computercraft.api.filesystem;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/lua/ArgumentHelper.java

@@ -0,0 +1,334 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
+
+import dan200.computercraft.api.peripheral.IComputerAccess;
+import dan200.computercraft.api.peripheral.IPeripheral;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Map;
+
+/**
+ * Provides methods for extracting values and validating Lua arguments, such as those provided to
+ * {@link ILuaObject#callMethod(ILuaContext, int, Object[])} or
+ * {@link IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])}.
+ *
+ * This provides two sets of functions: the {@code get*} methods, which require an argument to be valid, and
+ * {@code opt*}, which accept a default value and return that if the argument was not present or was {@code null}.
+ * If the argument is of the wrong type, a suitable error message will be thrown, with a similar format to Lua's own
+ * error messages.
+ *
+ * <h2>Example usage:</h2>
+ * <pre>
+ * {@code
+ * int slot = getInt( args, 0 );
+ * int amount = optInt( args, 1, 64 );
+ * }
+ * </pre>
+ */
+public final class ArgumentHelper
+{
+    private ArgumentHelper()
+    {
+    }
+
+    /**
+     * Get a string representation of the given value's type.
+     *
+     * @param value The value whose type we are trying to compute.
+     * @return A string representation of the given value's type, in a similar format to that provided by Lua's
+     * {@code type} function.
+     */
+    @Nonnull
+    public static String getType( @Nullable Object value )
+    {
+        if( value == null ) return "nil";
+        if( value instanceof String ) return "string";
+        if( value instanceof Boolean ) return "boolean";
+        if( value instanceof Number ) return "number";
+        if( value instanceof Map ) return "table";
+        return "userdata";
+    }
+
+    /**
+     * Construct a "bad argument" exception, from an expected type and the actual value provided.
+     *
+     * @param index    The argument number, starting from 0.
+     * @param expected The expected type for this argument.
+     * @param actual   The actual value provided for this argument.
+     * @return The constructed exception, which should be thrown immediately.
+     */
+    @Nonnull
+    public static LuaException badArgumentOf( int index, @Nonnull String expected, @Nullable Object actual )
+    {
+        return badArgument( index, expected, getType( actual ) );
+    }
+
+    /**
+     * Construct a "bad argument" exception, from an expected and actual type.
+     *
+     * @param index    The argument number, starting from 0.
+     * @param expected The expected type for this argument.
+     * @param actual   The provided type for this argument.
+     * @return The constructed exception, which should be thrown immediately.
+     */
+    @Nonnull
+    public static LuaException badArgument( int index, @Nonnull String expected, @Nonnull String actual )
+    {
+        return new LuaException( "bad argument #" + (index + 1) + " (" + expected + " expected, got " + actual + ")" );
+    }
+
+    /**
+     * Get an argument as a double.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @return The argument's value.
+     * @throws LuaException If the value is not a number.
+     * @see #getFiniteDouble(Object[], int) if you require this to be finite (i.e. not infinite or NaN).
+     */
+    public static double getDouble( @Nonnull Object[] args, int index ) throws LuaException
+    {
+        if( index >= args.length ) throw badArgument( index, "number", "nil" );
+        Object value = args[index];
+        if( !(value instanceof Number) ) throw badArgumentOf( index, "number", value );
+        return ((Number) value).doubleValue();
+    }
+
+    /**
+     * Get an argument as an integer.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @return The argument's value.
+     * @throws LuaException If the value is not an integer.
+     */
+    public static int getInt( @Nonnull Object[] args, int index ) throws LuaException
+    {
+        return (int) getLong( args, index );
+    }
+
+    /**
+     * Get an argument as a long.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @return The argument's value.
+     * @throws LuaException If the value is not a long.
+     */
+    public static long getLong( @Nonnull Object[] args, int index ) throws LuaException
+    {
+        if( index >= args.length ) throw badArgument( index, "number", "nil" );
+        Object value = args[index];
+        if( !(value instanceof Number) ) throw badArgumentOf( index, "number", value );
+        return checkFinite( index, (Number) value ).longValue();
+    }
+
+    /**
+     * Get an argument as a finite number (not infinite or NaN).
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @return The argument's value.
+     * @throws LuaException If the value is not finite.
+     */
+    public static double getFiniteDouble( @Nonnull Object[] args, int index ) throws LuaException
+    {
+        return checkFinite( index, getDouble( args, index ) );
+    }
+
+    /**
+     * Get an argument as a boolean.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @return The argument's value.
+     * @throws LuaException If the value is not a boolean.
+     */
+    public static boolean getBoolean( @Nonnull Object[] args, int index ) throws LuaException
+    {
+        if( index >= args.length ) throw badArgument( index, "boolean", "nil" );
+        Object value = args[index];
+        if( !(value instanceof Boolean) ) throw badArgumentOf( index, "boolean", value );
+        return (Boolean) value;
+    }
+
+    /**
+     * Get an argument as a string.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @return The argument's value.
+     * @throws LuaException If the value is not a string.
+     */
+    @Nonnull
+    public static String getString( @Nonnull Object[] args, int index ) throws LuaException
+    {
+        if( index >= args.length ) throw badArgument( index, "string", "nil" );
+        Object value = args[index];
+        if( !(value instanceof String) ) throw badArgumentOf( index, "string", value );
+        return (String) value;
+    }
+
+    /**
+     * Get an argument as a table.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @return The argument's value.
+     * @throws LuaException If the value is not a table.
+     */
+    @Nonnull
+    public static Map<?, ?> getTable( @Nonnull Object[] args, int index ) throws LuaException
+    {
+        if( index >= args.length ) throw badArgument( index, "table", "nil" );
+        Object value = args[index];
+        if( !(value instanceof Map) ) throw badArgumentOf( index, "table", value );
+        return (Map<?, ?>) value;
+    }
+
+    /**
+     * Get an argument as a double.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @param def   The default value, if this argument is not given.
+     * @return The argument's value, or {@code def} if none was provided.
+     * @throws LuaException If the value is not a number.
+     */
+    public static double optDouble( @Nonnull Object[] args, int index, double def ) throws LuaException
+    {
+        Object value = index < args.length ? args[index] : null;
+        if( value == null ) return def;
+        if( !(value instanceof Number) ) throw badArgumentOf( index, "number", value );
+        return ((Number) value).doubleValue();
+    }
+
+    /**
+     * Get an argument as an int.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @param def   The default value, if this argument is not given.
+     * @return The argument's value, or {@code def} if none was provided.
+     * @throws LuaException If the value is not a number.
+     */
+    public static int optInt( @Nonnull Object[] args, int index, int def ) throws LuaException
+    {
+        return (int) optLong( args, index, def );
+    }
+
+    /**
+     * Get an argument as a long.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @param def   The default value, if this argument is not given.
+     * @return The argument's value, or {@code def} if none was provided.
+     * @throws LuaException If the value is not a number.
+     */
+    public static long optLong( @Nonnull Object[] args, int index, long def ) throws LuaException
+    {
+        Object value = index < args.length ? args[index] : null;
+        if( value == null ) return def;
+        if( !(value instanceof Number) ) throw badArgumentOf( index, "number", value );
+        return checkFinite( index, (Number) value ).longValue();
+    }
+
+    /**
+     * Get an argument as a finite number (not infinite or NaN).
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @param def   The default value, if this argument is not given.
+     * @return The argument's value, or {@code def} if none was provided.
+     * @throws LuaException If the value is not finite.
+     */
+    public static double optFiniteDouble( @Nonnull Object[] args, int index, double def ) throws LuaException
+    {
+        return checkFinite( index, optDouble( args, index, def ) );
+    }
+
+    /**
+     * Get an argument as a boolean.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @param def   The default value, if this argument is not given.
+     * @return The argument's value, or {@code def} if none was provided.
+     * @throws LuaException If the value is not a boolean.
+     */
+    public static boolean optBoolean( @Nonnull Object[] args, int index, boolean def ) throws LuaException
+    {
+        Object value = index < args.length ? args[index] : null;
+        if( value == null ) return def;
+        if( !(value instanceof Boolean) ) throw badArgumentOf( index, "boolean", value );
+        return (Boolean) value;
+    }
+
+    /**
+     * Get an argument as a string.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @param def   The default value, if this argument is not given.
+     * @return The argument's value, or {@code def} if none was provided.
+     * @throws LuaException If the value is not a string.
+     */
+    public static String optString( @Nonnull Object[] args, int index, String def ) throws LuaException
+    {
+        Object value = index < args.length ? args[index] : null;
+        if( value == null ) return def;
+        if( !(value instanceof String) ) throw badArgumentOf( index, "string", value );
+        return (String) value;
+    }
+
+    /**
+     * Get an argument as a table.
+     *
+     * @param args  The arguments to extract from.
+     * @param index The index into the argument array to read from.
+     * @param def   The default value, if this argument is not given.
+     * @return The argument's value, or {@code def} if none was provided.
+     * @throws LuaException If the value is not a table.
+     */
+    public static Map<?, ?> optTable( @Nonnull Object[] args, int index, Map<Object, Object> def ) throws LuaException
+    {
+        Object value = index < args.length ? args[index] : null;
+        if( value == null ) return def;
+        if( !(value instanceof Map) ) throw badArgumentOf( index, "table", value );
+        return (Map<?, ?>) value;
+    }
+
+    private static Number checkFinite( int index, Number value ) throws LuaException
+    {
+        checkFinite( index, value.doubleValue() );
+        return value;
+    }
+
+    private static double checkFinite( int index, double value ) throws LuaException
+    {
+        if( !Double.isFinite( value ) ) throw badArgument( index, "number", getNumericType( value ) );
+        return value;
+    }
+
+    /**
+     * Returns a more detailed representation of this number's type. If this is finite, it will just return "number",
+     * otherwise it returns whether it is infinite or NaN.
+     *
+     * @param value The value to extract the type for.
+     * @return This value's numeric type.
+     */
+    @Nonnull
+    public static String getNumericType( double value )
+    {
+        if( Double.isNaN( value ) ) return "nan";
+        if( value == Double.POSITIVE_INFINITY ) return "inf";
+        if( value == Double.NEGATIVE_INFINITY ) return "-inf";
+        return "number";
+    }
+}

src/main/java/dan200/computercraft/api/lua/IArguments.java

@@ -1,418 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import static dan200.computercraft.api.lua.LuaValues.checkFinite;
-
-import java.nio.ByteBuffer;
-import java.util.Map;
-import java.util.Optional;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-/**
- * The arguments passed to a function.
- */
-public interface IArguments {
-    /**
-     * Drop a number of arguments. The returned arguments instance will access arguments at position {@code i + count}, rather than {@code i}. However,
-     * errors will still use the given argument index.
-     *
-     * @param count The number of arguments to drop.
-     * @return The new {@link IArguments} instance.
-     */
-    IArguments drop(int count);
-
-    default Object[] getAll() {
-        Object[] result = new Object[this.count()];
-        for (int i = 0; i < result.length; i++) {
-            result[i] = this.get(i);
-        }
-        return result;
-    }
-
-    /**
-     * Get the number of arguments passed to this function.
-     *
-     * @return The number of passed arguments.
-     */
-    int count();
-
-    /**
-     * Get the argument at the specific index. The returned value must obey the following conversion rules:
-     *
-     * <ul>
-     *   <li>Lua values of type "string" will be represented by a {@link String}.</li>
-     *   <li>Lua values of type "number" will be represented by a {@link Number}.</li>
-     *   <li>Lua values of type "boolean" will be represented by a {@link Boolean}.</li>
-     *   <li>Lua values of type "table" will be represented by a {@link Map}.</li>
-     *   <li>Lua values of any other type will be represented by a {@code null} value.</li>
-     * </ul>
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@code null} if not present.
-     */
-    @Nullable
-    Object get(int index);
-
-    /**
-     * Get an argument as an integer.
-     *
-     * @param index The argument number.
-     * @return The argument's value.
-     * @throws LuaException If the value is not an integer.
-     */
-    default int getInt(int index) throws LuaException {
-        return (int) this.getLong(index);
-    }
-
-    /**
-     * Get an argument as a long.
-     *
-     * @param index The argument number.
-     * @return The argument's value.
-     * @throws LuaException If the value is not a long.
-     */
-    default long getLong(int index) throws LuaException {
-        Object value = this.get(index);
-        if (!(value instanceof Number)) {
-            throw LuaValues.badArgumentOf(index, "number", value);
-        }
-        return LuaValues.checkFiniteNum(index, (Number) value)
-                        .longValue();
-    }
-
-    /**
-     * Get an argument as a finite number (not infinite or NaN).
-     *
-     * @param index The argument number.
-     * @return The argument's value.
-     * @throws LuaException If the value is not finite.
-     */
-    default double getFiniteDouble(int index) throws LuaException {
-        return checkFinite(index, this.getDouble(index));
-    }
-
-    /**
-     * Get an argument as a double.
-     *
-     * @param index The argument number.
-     * @return The argument's value.
-     * @throws LuaException If the value is not a number.
-     * @see #getFiniteDouble(int) if you require this to be finite (i.e. not infinite or NaN).
-     */
-    default double getDouble(int index) throws LuaException {
-        Object value = this.get(index);
-        if (!(value instanceof Number)) {
-            throw LuaValues.badArgumentOf(index, "number", value);
-        }
-        return ((Number) value).doubleValue();
-    }
-
-    /**
-     * Get an argument as a boolean.
-     *
-     * @param index The argument number.
-     * @return The argument's value.
-     * @throws LuaException If the value is not a boolean.
-     */
-    default boolean getBoolean(int index) throws LuaException {
-        Object value = this.get(index);
-        if (!(value instanceof Boolean)) {
-            throw LuaValues.badArgumentOf(index, "boolean", value);
-        }
-        return (Boolean) value;
-    }
-
-    /**
-     * Get a string argument as a byte array.
-     *
-     * @param index The argument number.
-     * @return The argument's value. This is a <em>read only</em> buffer.
-     * @throws LuaException If the value is not a string.
-     */
-    @Nonnull
-    default ByteBuffer getBytes(int index) throws LuaException {
-        return LuaValues.encode(this.getString(index));
-    }
-
-    /**
-     * Get an argument as a string.
-     *
-     * @param index The argument number.
-     * @return The argument's value.
-     * @throws LuaException If the value is not a string.
-     */
-    @Nonnull
-    default String getString(int index) throws LuaException {
-        Object value = this.get(index);
-        if (!(value instanceof String)) {
-            throw LuaValues.badArgumentOf(index, "string", value);
-        }
-        return (String) value;
-    }
-
-    /**
-     * Get a string argument as an enum value.
-     *
-     * @param index The argument number.
-     * @param klass The type of enum to parse.
-     * @param <T> The type of enum to parse.
-     * @return The argument's value.
-     * @throws LuaException If the value is not a string or not a valid option for this enum.
-     */
-    @Nonnull
-    default <T extends Enum<T>> T getEnum(int index, Class<T> klass) throws LuaException {
-        return LuaValues.checkEnum(index, klass, this.getString(index));
-    }
-
-    /**
-     * Get an argument as a table.
-     *
-     * @param index The argument number.
-     * @return The argument's value.
-     * @throws LuaException If the value is not a table.
-     */
-    @Nonnull
-    default Map<?, ?> getTable(int index) throws LuaException {
-        Object value = this.get(index);
-        if (!(value instanceof Map)) {
-            throw LuaValues.badArgumentOf(index, "table", value);
-        }
-        return (Map<?, ?>) value;
-    }
-
-    /**
-     * Get a string argument as a byte array.
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present. This is a <em>read only</em> buffer.
-     * @throws LuaException If the value is not a string.
-     */
-    default Optional<ByteBuffer> optBytes(int index) throws LuaException {
-        return this.optString(index).map(LuaValues::encode);
-    }
-
-    /**
-     * Get an argument as a string.
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present.
-     * @throws LuaException If the value is not a string.
-     */
-    default Optional<String> optString(int index) throws LuaException {
-        Object value = this.get(index);
-        if (value == null) {
-            return Optional.empty();
-        }
-        if (!(value instanceof String)) {
-            throw LuaValues.badArgumentOf(index, "string", value);
-        }
-        return Optional.of((String) value);
-    }
-
-    /**
-     * Get a string argument as an enum value.
-     *
-     * @param index The argument number.
-     * @param klass The type of enum to parse.
-     * @param <T> The type of enum to parse.
-     * @return The argument's value.
-     * @throws LuaException If the value is not a string or not a valid option for this enum.
-     */
-    @Nonnull
-    default <T extends Enum<T>> Optional<T> optEnum(int index, Class<T> klass) throws LuaException {
-        Optional<String> str = this.optString(index);
-        return str.isPresent() ? Optional.of(LuaValues.checkEnum(index, klass, str.get())) : Optional.empty();
-    }
-
-    /**
-     * Get an argument as a double.
-     *
-     * @param index The argument number.
-     * @param def The default value, if this argument is not given.
-     * @return The argument's value, or {@code def} if none was provided.
-     * @throws LuaException If the value is not a number.
-     */
-    default double optDouble(int index, double def) throws LuaException {
-        return this.optDouble(index).orElse(def);
-    }
-
-    /**
-     * Get an argument as a double.
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present.
-     * @throws LuaException If the value is not a number.
-     */
-    @Nonnull
-    default Optional<Double> optDouble(int index) throws LuaException {
-        Object value = this.get(index);
-        if (value == null) {
-            return Optional.empty();
-        }
-        if (!(value instanceof Number)) {
-            throw LuaValues.badArgumentOf(index, "number", value);
-        }
-        return Optional.of(((Number) value).doubleValue());
-    }
-
-    /**
-     * Get an argument as an int.
-     *
-     * @param index The argument number.
-     * @param def The default value, if this argument is not given.
-     * @return The argument's value, or {@code def} if none was provided.
-     * @throws LuaException If the value is not a number.
-     */
-    default int optInt(int index, int def) throws LuaException {
-        return this.optInt(index).orElse(def);
-    }
-
-    /**
-     * Get an argument as an int.
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present.
-     * @throws LuaException If the value is not a number.
-     */
-    @Nonnull
-    default Optional<Integer> optInt(int index) throws LuaException {
-        return this.optLong(index).map(Long::intValue);
-    }
-
-    /**
-     * Get an argument as a long.
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present.
-     * @throws LuaException If the value is not a number.
-     */
-    default Optional<Long> optLong(int index) throws LuaException {
-        Object value = this.get(index);
-        if (value == null) {
-            return Optional.empty();
-        }
-        if (!(value instanceof Number)) {
-            throw LuaValues.badArgumentOf(index, "number", value);
-        }
-        return Optional.of(LuaValues.checkFiniteNum(index, (Number) value)
-                                    .longValue());
-    }
-
-    /**
-     * Get an argument as a long.
-     *
-     * @param index The argument number.
-     * @param def The default value, if this argument is not given.
-     * @return The argument's value, or {@code def} if none was provided.
-     * @throws LuaException If the value is not a number.
-     */
-    default long optLong(int index, long def) throws LuaException {
-        return this.optLong(index).orElse(def);
-    }
-
-    /**
-     * Get an argument as a finite number (not infinite or NaN).
-     *
-     * @param index The argument number.
-     * @param def The default value, if this argument is not given.
-     * @return The argument's value, or {@code def} if none was provided.
-     * @throws LuaException If the value is not finite.
-     */
-    default double optFiniteDouble(int index, double def) throws LuaException {
-        return this.optFiniteDouble(index).orElse(def);
-    }
-
-    /**
-     * Get an argument as a finite number (not infinite or NaN).
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present.
-     * @throws LuaException If the value is not finite.
-     */
-    default Optional<Double> optFiniteDouble(int index) throws LuaException {
-        Optional<Double> value = this.optDouble(index);
-        if (value.isPresent()) {
-            LuaValues.checkFiniteNum(index, value.get());
-        }
-        return value;
-    }
-
-    /**
-     * Get an argument as a boolean.
-     *
-     * @param index The argument number.
-     * @param def The default value, if this argument is not given.
-     * @return The argument's value, or {@code def} if none was provided.
-     * @throws LuaException If the value is not a boolean.
-     */
-    default boolean optBoolean(int index, boolean def) throws LuaException {
-        return this.optBoolean(index).orElse(def);
-    }
-
-    /**
-     * Get an argument as a boolean.
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present.
-     * @throws LuaException If the value is not a boolean.
-     */
-    default Optional<Boolean> optBoolean(int index) throws LuaException {
-        Object value = this.get(index);
-        if (value == null) {
-            return Optional.empty();
-        }
-        if (!(value instanceof Boolean)) {
-            throw LuaValues.badArgumentOf(index, "boolean", value);
-        }
-        return Optional.of((Boolean) value);
-    }
-
-    /**
-     * Get an argument as a string.
-     *
-     * @param index The argument number.
-     * @param def The default value, if this argument is not given.
-     * @return The argument's value, or {@code def} if none was provided.
-     * @throws LuaException If the value is not a string.
-     */
-    default String optString(int index, String def) throws LuaException {
-        return this.optString(index).orElse(def);
-    }
-
-    /**
-     * Get an argument as a table.
-     *
-     * @param index The argument number.
-     * @param def The default value, if this argument is not given.
-     * @return The argument's value, or {@code def} if none was provided.
-     * @throws LuaException If the value is not a table.
-     */
-    default Map<?, ?> optTable(int index, Map<Object, Object> def) throws LuaException {
-        return this.optTable(index).orElse(def);
-    }
-
-    /**
-     * Get an argument as a table.
-     *
-     * @param index The argument number.
-     * @return The argument's value, or {@link Optional#empty()} if not present.
-     * @throws LuaException If the value is not a table.
-     */
-    default Optional<Map<?, ?>> optTable(int index) throws LuaException {
-        Object value = this.get(index);
-        if (value == null) {
-            return Optional.empty();
-        }
-        if (!(value instanceof Map)) {
-            throw LuaValues.badArgumentOf(index, "map", value);
-        }
-        return Optional.of((Map<?, ?>) value);
-    }
-}

src/main/java/dan200/computercraft/api/lua/IComputerSystem.java

@@ -3,18 +3,19 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
 
-import javax.annotation.Nullable;
-
 import dan200.computercraft.api.filesystem.IFileSystem;
 import dan200.computercraft.api.peripheral.IComputerAccess;
 
+import javax.annotation.Nullable;
+
 /**
- * An interface passed to {@link ILuaAPIFactory} in order to provide additional information about a computer.
+ * An interface passed to {@link ILuaAPIFactory} in order to provide additional information
+ * about a computer.
  */
-public interface IComputerSystem extends IComputerAccess {
+public interface IComputerSystem extends IComputerAccess
+{
     /**
      * Get the file system for this computer.
      *

src/main/java/dan200/computercraft/api/lua/IDynamicLuaObject.java

@@ -1,40 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import javax.annotation.Nonnull;
-
-import dan200.computercraft.api.peripheral.IDynamicPeripheral;
-
-/**
- * An interface for representing custom objects returned by peripherals or other Lua objects.
- *
- * Generally, one does not need to implement this type - it is sufficient to return an object with some methods annotated with {@link LuaFunction}. {@link
- * IDynamicLuaObject} is useful when you wish your available methods to change at runtime.
- */
-public interface IDynamicLuaObject {
-    /**
-     * Get the names of the methods that this object implements. This should not change over the course of the object's lifetime.
-     *
-     * @return The method names this object provides.
-     * @see IDynamicPeripheral#getMethodNames()
-     */
-    @Nonnull
-    String[] getMethodNames();
-
-    /**
-     * Called when a user calls one of the methods that this object implements.
-     *
-     * @param context The context of the currently running lua thread. This can be used to wait for events or otherwise yield.
-     * @param method An integer identifying which method index from {@link #getMethodNames()} the computer wishes to call.
-     * @param arguments The arguments for this method.
-     * @return The result of this function. Either an immediate value ({@link MethodResult#of(Object...)} or an instruction to yield.
-     * @throws LuaException If the function threw an exception.
-     */
-    @Nonnull
-    MethodResult callMethod(@Nonnull ILuaContext context, int method, @Nonnull IArguments arguments) throws LuaException;
-}

src/main/java/dan200/computercraft/api/lua/ILuaAPI.java

@@ -3,22 +3,21 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
 
 import dan200.computercraft.api.ComputerCraftAPI;
 
 /**
- * Represents a Lua object which is stored as a global variable on computer startup. This must either provide {@link LuaFunction} annotated functions or
- * implement {@link IDynamicLuaObject}.
+ * Represents a {@link ILuaObject} which is stored as a global variable on computer startup.
  *
- * Before implementing this interface, consider alternative methods of providing methods. It is generally preferred to use peripherals to provide
- * functionality to users.
+ * Before implementing this interface, consider alternative methods of providing methods. It is generally preferred
+ * to use peripherals to provide functionality to users.
  *
  * @see ILuaAPIFactory
  * @see ComputerCraftAPI#registerAPIFactory(ILuaAPIFactory)
  */
-public interface ILuaAPI {
+public interface ILuaAPI extends ILuaObject
+{
     /**
      * Get the globals this API will be assigned to. This will override any other global, so you should
      *
@@ -31,13 +30,15 @@ public interface ILuaAPI {
      *
      * One should only interact with the file system.
      */
-    default void startup() {
+    default void startup()
+    {
     }
 
     /**
      * Called every time the computer is ticked. This can be used to process various.
      */
-    default void update() {
+    default void update()
+    {
     }
 
     /**
@@ -45,6 +46,7 @@ public interface ILuaAPI {
      *
      * This should reset the state of the object, disposing any remaining file handles, or other resources.
      */
-    default void shutdown() {
+    default void shutdown()
+    {
     }
 }

src/main/java/dan200/computercraft/api/lua/ILuaAPIFactory.java

@@ -3,14 +3,13 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
 
+import dan200.computercraft.api.ComputerCraftAPI;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-import dan200.computercraft.api.ComputerCraftAPI;
-
 /**
  * Construct an {@link ILuaAPI} for a specific computer.
  *
@@ -18,7 +17,8 @@ import dan200.computercraft.api.ComputerCraftAPI;
  * @see ComputerCraftAPI#registerAPIFactory(ILuaAPIFactory)
  */
 @FunctionalInterface
-public interface ILuaAPIFactory {
+public interface ILuaAPIFactory
+{
     /**
      * Create a new API instance for a given computer.
      *
@@ -26,5 +26,5 @@ public interface ILuaAPIFactory {
      * @return The created API, or {@code null} if one should not be injected.
      */
     @Nullable
-    ILuaAPI create(@Nonnull IComputerSystem computer);
+    ILuaAPI create( @Nonnull IComputerSystem computer );
 }

src/main/java/dan200/computercraft/api/lua/ILuaCallback.java

@@ -1,26 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import javax.annotation.Nonnull;
-
-/**
- * A continuation which is called when this coroutine is resumed.
- *
- * @see MethodResult#yield(Object[], ILuaCallback)
- */
-public interface ILuaCallback {
-    /**
-     * Resume this coroutine.
-     *
-     * @param args The result of resuming this coroutine. These will have the same form as described in {@link LuaFunction}.
-     * @return The result of this continuation. Either the result to return to the callee, or another yield.
-     * @throws LuaException On an error.
-     */
-    @Nonnull
-    MethodResult resume(Object[] args) throws LuaException;
-}

src/main/java/dan200/computercraft/api/lua/ILuaContext.java

@@ -3,27 +3,102 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
 
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 
 /**
- * An interface passed to peripherals and {@link IDynamicLuaObject}s by computers or turtles, providing methods that allow the peripheral call to interface
- * with the computer.
+ * An interface passed to peripherals and {@link ILuaObject}s by computers or turtles, providing methods
+ * that allow the peripheral call to wait for events before returning, just like in lua. This is very useful if you need
+ * to signal work to be performed on the main thread, and don't want to return until the work has been completed.
  */
-public interface ILuaContext {
+public interface ILuaContext
+{
     /**
-     * Queue a task to be executed on the main server thread at the beginning of next tick, but do not wait for it to complete. This should be used when you
-     * need to interact with the world in a thread-safe manner but do not care about the result or you wish to run asynchronously.
+     * Wait for an event to occur on the computer, suspending the thread until it arises. This method is exactly
+     * equivalent to {@code os.pullEvent()} in lua.
      *
-     * When the task has finished, it will enqueue a {@code task_completed} event, which takes the task id, a success value and the return values, or an
-     * error message if it failed.
+     * @param filter A specific event to wait for, or null to wait for any event.
+     * @return An object array containing the name of the event that occurred, and any event parameters.
+     * @throws LuaException         If the user presses CTRL+T to terminate the current program while pullEvent() is
+     *                              waiting for an event, a "Terminated" exception will be thrown here.
+     *
+     *                              Do not attempt to catch this exception. You should use {@link #pullEventRaw(String)}
+     *                              should you wish to disable termination.
+     * @throws InterruptedException If the user shuts down or reboots the computer while pullEvent() is waiting for an
+     *                              event, InterruptedException will be thrown. This exception must not be caught or
+     *                              intercepted, or the computer will leak memory and end up in a broken state.
+     */
+    @Nonnull
+    default Object[] pullEvent( @Nullable String filter ) throws LuaException, InterruptedException
+    {
+        Object[] results = pullEventRaw( filter );
+        if( results.length >= 1 && results[0].equals( "terminate" ) ) throw new LuaException( "Terminated", 0 );
+        return results;
+    }
+
+    /**
+     * The same as {@link #pullEvent(String)}, except "terminated" events are ignored. Only use this if you want to
+     * prevent program termination, which is not recommended. This method is exactly equivalent to
+     * {@code os.pullEventRaw()} in lua.
+     *
+     * @param filter A specific event to wait for, or null to wait for any event.
+     * @return An object array containing the name of the event that occurred, and any event parameters.
+     * @throws InterruptedException If the user shuts down or reboots the computer while pullEventRaw() is waiting for
+     *                              an event, InterruptedException will be thrown. This exception must not be caught or
+     *                              intercepted, or the computer will leak memory and end up in a broken state.
+     * @see #pullEvent(String)
+     */
+    @Nonnull
+    default Object[] pullEventRaw( @Nullable String filter ) throws InterruptedException
+    {
+        return yield( new Object[] { filter } );
+    }
+
+    /**
+     * Yield the current coroutine with some arguments until it is resumed. This method is exactly equivalent to
+     * {@code coroutine.yield()} in lua. Use {@code pullEvent()} if you wish to wait for events.
+     *
+     * @param arguments An object array containing the arguments to pass to coroutine.yield()
+     * @return An object array containing the return values from coroutine.yield()
+     * @throws InterruptedException If the user shuts down or reboots the computer the coroutine is suspended,
+     *                              InterruptedException will be thrown. This exception must not be caught or
+     *                              intercepted, or the computer will leak memory and end up in a broken state.
+     * @see #pullEvent(String)
+     */
+    @Nonnull
+    Object[] yield( @Nullable Object[] arguments ) throws InterruptedException;
+
+    /**
+     * Queue a task to be executed on the main server thread at the beginning of next tick, waiting for it to complete.
+     * This should be used when you need to interact with the world in a thread-safe manner.
+     *
+     * Note that the return values of your task are handled as events, meaning more complex objects such as maps or
+     * {@link ILuaObject} will not preserve their identities.
+     *
+     * @param task The task to execute on the main thread.
+     * @return The objects returned by {@code task}.
+     * @throws LuaException         If the task could not be queued, or if the task threw an exception.
+     * @throws InterruptedException If the user shuts down or reboots the computer the coroutine is suspended,
+     *                              InterruptedException will be thrown. This exception must not be caught or
+     *                              intercepted, or the computer will leak memory and end up in a broken state.
+     */
+    @Nullable
+    Object[] executeMainThreadTask( @Nonnull ILuaTask task ) throws LuaException, InterruptedException;
+
+    /**
+     * Queue a task to be executed on the main server thread at the beginning of next tick, but do not wait for it to
+     * complete. This should be used when you need to interact with the world in a thread-safe manner but do not care
+     * about the result or you wish to run asynchronously.
+     *
+     * When the task has finished, it will enqueue a {@code task_completed} event, which takes the task id, a success
+     * value and the return values, or an error message if it failed. If you need to wait on this event, it may be
+     * better to use {@link #executeMainThreadTask(ILuaTask)}.
      *
      * @param task The task to execute on the main thread.
      * @return The "id" of the task. This will be the first argument to the {@code task_completed} event.
      * @throws LuaException If the task could not be queued.
-     * @see LuaFunction#mainThread() To run functions on the main thread and return their results synchronously.
      */
-    long issueMainThreadTask(@Nonnull ILuaTask task) throws LuaException;
+    long issueMainThreadTask( @Nonnull ILuaTask task ) throws LuaException;
 }

src/main/java/dan200/computercraft/api/lua/ILuaFunction.java

@@ -1,29 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import javax.annotation.Nonnull;
-
-/**
- * A function, which can be called from Lua. If you need to return a table of functions, it is recommended to use an object with {@link LuaFunction}
- * methods, or implement {@link IDynamicLuaObject}.
- *
- * @see MethodResult#of(Object)
- */
-@FunctionalInterface
-public interface ILuaFunction {
-    /**
-     * Call this function with a series of arguments. Note, this will <em>always</em> be called on the computer thread, and so its implementation must be
-     * thread-safe.
-     *
-     * @param arguments The arguments for this function
-     * @return The result of calling this function.
-     * @throws LuaException Upon Lua errors.
-     */
-    @Nonnull
-    MethodResult call(@Nonnull IArguments arguments) throws LuaException;
-}

src/main/java/dan200/computercraft/api/lua/ILuaObject.java

@@ -1,18 +1,55 @@
 /*
  * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2019. This API may be redistributed unmodified and in full only.
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
 
+import dan200.computercraft.api.peripheral.IComputerAccess;
+import dan200.computercraft.api.peripheral.IPeripheral;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-public interface ILuaObject {
+/**
+ * An interface for representing custom objects returned by {@link IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])}
+ * calls.
+ *
+ * Return objects implementing this interface to expose objects with methods to lua.
+ */
+public interface ILuaObject
+{
+    /**
+     * Get the names of the methods that this object implements. This works the same as {@link IPeripheral#getMethodNames()}.
+     * See that method for detailed documentation.
+     *
+     * @return The method names this object provides.
+     * @see IPeripheral#getMethodNames()
+     */
     @Nonnull
     String[] getMethodNames();
 
+    /**
+     * Called when a user calls one of the methods that this object implements. This works the same as
+     * {@link IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])}}. See that method for detailed
+     * documentation.
+     *
+     * @param context   The context of the currently running lua thread. This can be used to wait for events
+     *                  or otherwise yield.
+     * @param method    An integer identifying which of the methods from getMethodNames() the computercraft
+     *                  wishes to call. The integer indicates the index into the getMethodNames() table
+     *                  that corresponds to the string passed into peripheral.call()
+     * @param arguments The arguments for this method. See {@link IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])}
+     *                  the possible values and conversion rules.
+     * @return An array of objects, representing the values you wish to return to the Lua program.
+     * See {@link IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])} for the valid values and
+     * conversion rules.
+     * @throws LuaException         If the task could not be queued, or if the task threw an exception.
+     * @throws InterruptedException If the user shuts down or reboots the computer the coroutine is suspended,
+     *                              InterruptedException will be thrown. This exception must not be caught or
+     *                              intercepted, or the computer will leak memory and end up in a broken state.w
+     * @see IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])
+     */
     @Nullable
-    Object[] callMethod(@Nonnull ILuaContext context, int method, @Nonnull Object[] arguments) throws LuaException, InterruptedException;
+    Object[] callMethod( @Nonnull ILuaContext context, int method, @Nonnull Object[] arguments ) throws LuaException, InterruptedException;
 }

src/main/java/dan200/computercraft/api/lua/ILuaTask.java

@@ -3,25 +3,29 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
 
 import javax.annotation.Nullable;
 
 /**
- * A task which can be executed via {@link ILuaContext#issueMainThreadTask(ILuaTask)} This will be run on the main thread, at the beginning of the next
- * tick.
+ * A task which can be executed via {@link ILuaContext#executeMainThreadTask(ILuaTask)} or
+ * {@link ILuaContext#issueMainThreadTask(ILuaTask)}. This will be run on the main thread, at the beginning of the
+ * next tick.
  *
+ * @see ILuaContext#executeMainThreadTask(ILuaTask)
  * @see ILuaContext#issueMainThreadTask(ILuaTask)
  */
 @FunctionalInterface
-public interface ILuaTask {
+public interface ILuaTask
+{
     /**
      * Execute this task.
      *
-     * @return The arguments to add to the {@code task_completed} event.
-     * @throws LuaException If you throw any exception from this function, a lua error will be raised with the same message as your exception. Use this
-     *     to throw appropriate errors if the wrong arguments are supplied to your method.
+     * @return The arguments to add to the {@code task_completed} event. These will be returned by
+     * {@link ILuaContext#executeMainThreadTask(ILuaTask)}.
+     * @throws LuaException If you throw any exception from this function, a lua error will be raised with the
+     *                      same message as your exception. Use this to throw appropriate errors if the wrong
+     *                      arguments are supplied to your method.
      */
     @Nullable
     Object[] execute() throws LuaException;

src/main/java/dan200/computercraft/api/lua/LuaException.java

@@ -3,7 +3,6 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
 
 import javax.annotation.Nullable;
@@ -11,38 +10,35 @@ import javax.annotation.Nullable;
 /**
  * An exception representing an error in Lua, like that raised by the {@code error()} function.
  */
-public class LuaException extends Exception {
+public class LuaException extends Exception
+{
     private static final long serialVersionUID = -6136063076818512651L;
-    private final boolean hasLevel;
     private final int level;
 
-    public LuaException(@Nullable String message) {
-        super(message);
-        this.hasLevel = false;
-        this.level = 1;
+    public LuaException()
+    {
+        this( "error", 1 );
     }
 
-    public LuaException(@Nullable String message, int level) {
-        super(message);
-        this.hasLevel = true;
+    public LuaException( @Nullable String message )
+    {
+        this( message, 1 );
+    }
+
+    public LuaException( @Nullable String message, int level )
+    {
+        super( message );
         this.level = level;
     }
 
     /**
-     * Whether a level was explicitly specified when constructing. This is used to determine
-     *
-     * @return Whether this has an explicit level.
-     */
-    public boolean hasLevel() {
-        return this.hasLevel;
-    }
-
-    /**
-     * The level this error is raised at. Level 1 is the function's caller, level 2 is that function's caller, and so on.
+     * The level this error is raised at. Level 1 is the function's caller, level 2 is that function's caller, and so
+     * on.
      *
      * @return The level to raise the error at.
      */
-    public int getLevel() {
-        return this.level;
+    public int getLevel()
+    {
+        return level;
     }
 }

src/main/java/dan200/computercraft/api/lua/LuaFunction.java

@@ -1,61 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.util.Map;
-import java.util.Optional;
-
-import dan200.computercraft.api.peripheral.IComputerAccess;
-import dan200.computercraft.api.peripheral.IPeripheral;
-
-/**
- * Used to mark a Java function which is callable from Lua.
- *
- * Methods annotated with {@link LuaFunction} must be public final instance methods. They can have any number of parameters, but they must be of the
- * following types:
- *
- * <ul>
- *   <li>{@link ILuaContext} (and {@link IComputerAccess} if on a {@link IPeripheral})</li>
- *   <li>{@link IArguments}: The arguments supplied to this function.</li>
- *   <li>
- *     Alternatively, one may specify the desired arguments as normal parameters and the argument parsing code will
- *     be generated automatically.
- *
- *     Each parameter must be one of the given types supported by {@link IArguments} (for instance, {@link int} or
- *     {@link Map}). Optional values are supported by accepting a parameter of type {@link Optional}.
- *   </li>
- * </ul>
- *
- * This function may return {@link MethodResult}. However, if you simply return a value (rather than having to yield),
- * you may return {@code void}, a single value (either an object or a primitive like {@code int}) or array of objects.
- * These will be treated the same as {@link MethodResult#of()}, {@link MethodResult#of(Object)} and
- * {@link MethodResult#of(Object...)}.
- */
-@Documented
-@Retention (RetentionPolicy.RUNTIME)
-@Target (ElementType.METHOD)
-public @interface LuaFunction {
-    /**
-     * Explicitly specify the method names of this function. If not given, it uses the name of the annotated method.
-     *
-     * @return This function's name(s).
-     */
-    String[] value() default {};
-
-    /**
-     * Run this function on the main server thread. This should be specified for any method which interacts with Minecraft in a thread-unsafe manner.
-     *
-     * @return Whether this functi
-     * @see ILuaContext#issueMainThreadTask(ILuaTask)
-     */
-    boolean mainThread() default false;
-}

src/main/java/dan200/computercraft/api/lua/LuaValues.java

@@ -1,163 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import java.nio.ByteBuffer;
-import java.util.Map;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-/**
- * Various utility functions for operating with Lua values.
- *
- * @see IArguments
- */
-public final class LuaValues {
-    private LuaValues() {
-    }
-
-    /**
-     * Encode a Lua string into a read-only {@link ByteBuffer}.
-     *
-     * @param string The string to encode.
-     * @return The encoded string.
-     */
-    @Nonnull
-    public static ByteBuffer encode(@Nonnull String string) {
-        byte[] chars = new byte[string.length()];
-        for (int i = 0; i < chars.length; i++) {
-            char c = string.charAt(i);
-            chars[i] = c < 256 ? (byte) c : 63;
-        }
-
-        return ByteBuffer.wrap(chars)
-                         .asReadOnlyBuffer();
-    }
-
-    /**
-     * Construct a "bad argument" exception, from an expected type and the actual value provided.
-     *
-     * @param index The argument number, starting from 0.
-     * @param expected The expected type for this argument.
-     * @param actual The actual value provided for this argument.
-     * @return The constructed exception, which should be thrown immediately.
-     */
-    @Nonnull
-    public static LuaException badArgumentOf(int index, @Nonnull String expected, @Nullable Object actual) {
-        return badArgument(index, expected, getType(actual));
-    }
-
-    /**
-     * Construct a "bad argument" exception, from an expected and actual type.
-     *
-     * @param index The argument number, starting from 0.
-     * @param expected The expected type for this argument.
-     * @param actual The provided type for this argument.
-     * @return The constructed exception, which should be thrown immediately.
-     */
-    @Nonnull
-    public static LuaException badArgument(int index, @Nonnull String expected, @Nonnull String actual) {
-        return new LuaException("bad argument #" + (index + 1) + " (" + expected + " expected, got " + actual + ")");
-    }
-
-    /**
-     * Get a string representation of the given value's type.
-     *
-     * @param value The value whose type we are trying to compute.
-     * @return A string representation of the given value's type, in a similar format to that provided by Lua's {@code type} function.
-     */
-    @Nonnull
-    public static String getType(@Nullable Object value) {
-        if (value == null) {
-            return "nil";
-        }
-        if (value instanceof String) {
-            return "string";
-        }
-        if (value instanceof Boolean) {
-            return "boolean";
-        }
-        if (value instanceof Number) {
-            return "number";
-        }
-        if (value instanceof Map) {
-            return "table";
-        }
-        return "userdata";
-    }
-
-    /**
-     * Ensure a numeric argument is finite (i.e. not infinite or {@link Double#NaN}.
-     *
-     * @param index The argument index to check.
-     * @param value The value to check.
-     * @return The input {@code value}.
-     * @throws LuaException If this is not a finite number.
-     */
-    public static Number checkFiniteNum(int index, Number value) throws LuaException {
-        checkFinite(index, value.doubleValue());
-        return value;
-    }
-
-    /**
-     * Ensure a numeric argument is finite (i.e. not infinite or {@link Double#NaN}.
-     *
-     * @param index The argument index to check.
-     * @param value The value to check.
-     * @return The input {@code value}.
-     * @throws LuaException If this is not a finite number.
-     */
-    public static double checkFinite(int index, double value) throws LuaException {
-        if (!Double.isFinite(value)) {
-            throw badArgument(index, "number", getNumericType(value));
-        }
-        return value;
-    }
-
-    /**
-     * Returns a more detailed representation of this number's type. If this is finite, it will just return "number", otherwise it returns whether it is
-     * infinite or NaN.
-     *
-     * @param value The value to extract the type for.
-     * @return This value's numeric type.
-     */
-    @Nonnull
-    public static String getNumericType(double value) {
-        if (Double.isNaN(value)) {
-            return "nan";
-        }
-        if (value == Double.POSITIVE_INFINITY) {
-            return "inf";
-        }
-        if (value == Double.NEGATIVE_INFINITY) {
-            return "-inf";
-        }
-        return "number";
-    }
-
-    /**
-     * Ensure a string is a valid enum value.
-     *
-     * @param index The argument index to check.
-     * @param klass The class of the enum instance.
-     * @param value The value to extract.
-     * @param <T> The type of enum we are extracting.
-     * @return The parsed enum value.
-     * @throws LuaException If this is not a known enum value.
-     */
-    public static <T extends Enum<T>> T checkEnum(int index, Class<T> klass, String value) throws LuaException {
-        for (T possibility : klass.getEnumConstants()) {
-            if (possibility.name()
-                           .equalsIgnoreCase(value)) {
-                return possibility;
-            }
-        }
-
-        throw new LuaException("bad argument #" + (index + 1) + " (unknown option " + value + ")");
-    }
-}

src/main/java/dan200/computercraft/api/lua/MethodResult.java

@@ -1,162 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import java.nio.ByteBuffer;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-import dan200.computercraft.api.peripheral.IComputerAccess;
-
-/**
- * The result of invoking a Lua method.
- *
- * Method results either return a value immediately ({@link #of(Object...)} or yield control to the parent coroutine. When the current coroutine is resumed,
- * we invoke the provided {@link ILuaCallback#resume(Object[])} callback.
- */
-public final class MethodResult {
-    private static final MethodResult empty = new MethodResult(null, null);
-
-    private final Object[] result;
-    private final ILuaCallback callback;
-    private final int adjust;
-
-    private MethodResult(Object[] arguments, ILuaCallback callback) {
-        this.result = arguments;
-        this.callback = callback;
-        this.adjust = 0;
-    }
-
-    private MethodResult(Object[] arguments, ILuaCallback callback, int adjust) {
-        this.result = arguments;
-        this.callback = callback;
-        this.adjust = adjust;
-    }
-
-    /**
-     * Return no values immediately.
-     *
-     * @return A method result which returns immediately with no values.
-     */
-    @Nonnull
-    public static MethodResult of() {
-        return empty;
-    }
-
-    /**
-     * Return a single value immediately.
-     *
-     * Integers, doubles, floats, strings, booleans, {@link Map}, {@link Collection}s, arrays and {@code null} will be converted to their corresponding Lua
-     * type. {@code byte[]} and {@link ByteBuffer} will be treated as binary strings. {@link ILuaFunction} will be treated as a function.
-     *
-     * In order to provide a custom object with methods, one may return a {@link IDynamicLuaObject}, or an arbitrary class with {@link LuaFunction}
-     * annotations. Anything else will be converted to {@code nil}.
-     *
-     * @param value The value to return to the calling Lua function.
-     * @return A method result which returns immediately with the given value.
-     */
-    @Nonnull
-    public static MethodResult of(@Nullable Object value) {
-        return new MethodResult(new Object[] {value}, null);
-    }
-
-    /**
-     * Return any number of values immediately.
-     *
-     * @param values The values to return. See {@link #of(Object)} for acceptable values.
-     * @return A method result which returns immediately with the given values.
-     */
-    @Nonnull
-    public static MethodResult of(@Nullable Object... values) {
-        return values == null || values.length == 0 ? empty : new MethodResult(values, null);
-    }
-
-    /**
-     * Wait for an event to occur on the computer, suspending the thread until it arises. This method is exactly equivalent to {@code os.pullEvent()} in
-     * lua.
-     *
-     * @param filter A specific event to wait for, or null to wait for any event.
-     * @param callback The callback to resume with the name of the event that occurred, and any event parameters.
-     * @return The method result which represents this yield.
-     * @see IComputerAccess#queueEvent(String, Object[])
-     */
-    @Nonnull
-    public static MethodResult pullEvent(@Nullable String filter, @Nonnull ILuaCallback callback) {
-        Objects.requireNonNull(callback, "callback cannot be null");
-        return new MethodResult(new Object[] {filter}, results -> {
-            if (results.length >= 1 && results[0].equals("terminate")) {
-                throw new LuaException("Terminated", 0);
-            }
-            return callback.resume(results);
-        });
-    }
-
-    /**
-     * The same as {@link #pullEvent(String, ILuaCallback)}, except "terminated" events are ignored. Only use this if you want to prevent program
-     * termination, which is not recommended. This method is exactly equivalent to {@code os.pullEventRaw()} in Lua.
-     *
-     * @param filter A specific event to wait for, or null to wait for any event.
-     * @param callback The callback to resume with the name of the event that occurred, and any event parameters.
-     * @return The method result which represents this yield.
-     * @see #pullEvent(String, ILuaCallback)
-     */
-    @Nonnull
-    public static MethodResult pullEventRaw(@Nullable String filter, @Nonnull ILuaCallback callback) {
-        Objects.requireNonNull(callback, "callback cannot be null");
-        return new MethodResult(new Object[] {filter}, callback);
-    }
-
-    /**
-     * Yield the current coroutine with some arguments until it is resumed. This method is exactly equivalent to {@code coroutine.yield()} in lua. Use
-     * {@code pullEvent()} if you wish to wait for events.
-     *
-     * @param arguments An object array containing the arguments to pass to coroutine.yield()
-     * @param callback The callback to resume with an array containing the return values from coroutine.yield()
-     * @return The method result which represents this yield.
-     * @see #pullEvent(String, ILuaCallback)
-     */
-    @Nonnull
-    public static MethodResult yield(@Nullable Object[] arguments, @Nonnull ILuaCallback callback) {
-        Objects.requireNonNull(callback, "callback cannot be null");
-        return new MethodResult(arguments, callback);
-    }
-
-    @Nullable
-    public Object[] getResult() {
-        return this.result;
-    }
-
-    @Nullable
-    public ILuaCallback getCallback() {
-        return this.callback;
-    }
-
-    public int getErrorAdjust() {
-        return this.adjust;
-    }
-
-    /**
-     * Increase the Lua error by a specific amount. One should never need to use this function - it largely exists for some CC internal code.
-     *
-     * @param adjust The amount to increase the level by.
-     * @return The new {@link MethodResult} with an adjusted error. This has no effect on immediate results.
-     */
-    @Nonnull
-    public MethodResult adjustError(int adjust) {
-        if (adjust < 0) {
-            throw new IllegalArgumentException("cannot adjust by a negative amount");
-        }
-        if (adjust == 0 || this.callback == null) {
-            return this;
-        }
-        return new MethodResult(this.result, this.callback, this.adjust + adjust);
-    }
-}

src/main/java/dan200/computercraft/api/lua/ObjectArguments.java

@@ -1,66 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.lua;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-
-import javax.annotation.Nullable;
-
-/**
- * An implementation of {@link IArguments} which wraps an array of {@link Object}.
- */
-public final class ObjectArguments implements IArguments {
-    private static final IArguments EMPTY = new ObjectArguments();
-    private final List<Object> args;
-
-    @Deprecated
-    @SuppressWarnings ("unused")
-    public ObjectArguments(IArguments arguments) {
-        throw new IllegalStateException();
-    }
-
-    public ObjectArguments(Object... args) {
-        this.args = Arrays.asList(args);
-    }
-
-    public ObjectArguments(List<Object> args) {
-        this.args = Objects.requireNonNull(args);
-    }
-
-    @Override
-    public IArguments drop(int count) {
-        if (count < 0) {
-            throw new IllegalStateException("count cannot be negative");
-        }
-        if (count == 0) {
-            return this;
-        }
-        if (count >= this.args.size()) {
-            return EMPTY;
-        }
-
-        return new ObjectArguments(this.args.subList(count, this.args.size()));
-    }
-
-    @Override
-    public Object[] getAll() {
-        return this.args.toArray();
-    }
-
-    @Override
-    public int count() {
-        return this.args.size();
-    }
-
-    @Nullable
-    @Override
-    public Object get(int index) {
-        return index >= this.args.size() ? null : this.args.get(index);
-    }
-}

src/main/java/dan200/computercraft/api/lua/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Lua", apiVersion = "${version}" )
+package dan200.computercraft.api.lua;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/media/IMedia.java

@@ -3,25 +3,25 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.media;
 
+import dan200.computercraft.api.filesystem.IMount;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.SoundEvent;
+import net.minecraft.world.World;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-import dan200.computercraft.api.filesystem.IMount;
-
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.sound.SoundEvent;
-import net.minecraft.world.World;
-
 /**
  * Represents an item that can be placed in a disk drive and used by a Computer.
  *
- * Implement this interface on your {@link Item} class to allow it to be used in the drive. Alternatively, register a {@link IMediaProvider}.
+ * Implement this interface on your {@link Item} class to allow it to be used in the drive. Alternatively, register
+ * a {@link IMediaProvider}.
  */
-public interface IMedia {
+public interface IMedia
+{
     /**
      * Get a string representing the label of this item. Will be called via {@code disk.getLabel()} in lua.
      *
@@ -29,7 +29,7 @@ public interface IMedia {
      * @return The label. ie: "Dan's Programs".
      */
     @Nullable
-    String getLabel(@Nonnull ItemStack stack);
+    String getLabel( @Nonnull ItemStack stack );
 
     /**
      * Set a string representing the label of this item. Will be called vi {@code disk.setLabel()} in lua.
@@ -38,18 +38,21 @@ public interface IMedia {
      * @param label The string to set the label to.
      * @return true if the label was updated, false if the label may not be modified.
      */
-    default boolean setLabel(@Nonnull ItemStack stack, @Nullable String label) {
+    default boolean setLabel( @Nonnull ItemStack stack, @Nullable String label )
+    {
         return false;
     }
 
     /**
-     * If this disk represents an item with audio (like a record), get the readable name of the audio track. ie: "Jonathan Coulton - Still Alive"
+     * If this disk represents an item with audio (like a record), get the readable name of the audio track. ie:
+     * "Jonathan Coulton - Still Alive"
      *
      * @param stack The {@link ItemStack} to modify.
      * @return The name, or null if this item does not represent an item with audio.
      */
     @Nullable
-    default String getAudioTitle(@Nonnull ItemStack stack) {
+    default String getAudioTitle( @Nonnull ItemStack stack )
+    {
         return null;
     }
 
@@ -60,25 +63,27 @@ public interface IMedia {
      * @return The name, or null if this item does not represent an item with audio.
      */
     @Nullable
-    default SoundEvent getAudio(@Nonnull ItemStack stack) {
+    default SoundEvent getAudio( @Nonnull ItemStack stack )
+    {
         return null;
     }
 
     /**
-     * If this disk represents an item with data (like a floppy disk), get a mount representing it's contents. This will be mounted onto the filesystem of
-     * the computer while the media is in the disk drive.
+     * If this disk represents an item with data (like a floppy disk), get a mount representing it's contents. This will
+     * be mounted onto the filesystem of the computer while the media is in the disk drive.
      *
      * @param stack The {@link ItemStack} to modify.
      * @param world The world in which the item and disk drive reside.
-     * @return The mount, or null if this item does not represent an item with data. If the mount returned also implements {@link
-     *     dan200.computercraft.api.filesystem.IWritableMount}, it will mounted using mountWritable()
+     * @return The mount, or null if this item does not represent an item with data. If the mount returned also
+     * implements {@link dan200.computercraft.api.filesystem.IWritableMount}, it will mounted using mountWritable()
      * @see IMount
      * @see dan200.computercraft.api.filesystem.IWritableMount
      * @see dan200.computercraft.api.ComputerCraftAPI#createSaveDirMount(World, String, long)
-     * @see dan200.computercraft.api.ComputerCraftAPI#createResourceMount(String, String)
+     * @see dan200.computercraft.api.ComputerCraftAPI#createResourceMount(Class, String, String)
      */
     @Nullable
-    default IMount createDataMount(@Nonnull ItemStack stack, @Nonnull World world) {
+    default IMount createDataMount( @Nonnull ItemStack stack, @Nonnull World world )
+    {
         return null;
     }
 }

src/main/java/dan200/computercraft/api/media/IMediaProvider.java

@@ -3,21 +3,21 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.media;
 
+import net.minecraft.item.ItemStack;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-import net.minecraft.item.ItemStack;
-
 /**
  * This interface is used to provide {@link IMedia} implementations for {@link ItemStack}.
  *
  * @see dan200.computercraft.api.ComputerCraftAPI#registerMediaProvider(IMediaProvider)
  */
 @FunctionalInterface
-public interface IMediaProvider {
+public interface IMediaProvider
+{
     /**
      * Produce an IMedia implementation from an ItemStack.
      *
@@ -26,5 +26,5 @@ public interface IMediaProvider {
      * @see dan200.computercraft.api.ComputerCraftAPI#registerMediaProvider(IMediaProvider)
      */
     @Nullable
-    IMedia getMedia(@Nonnull ItemStack stack);
+    IMedia getMedia( @Nonnull ItemStack stack );
 }

src/main/java/dan200/computercraft/api/media/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Media", apiVersion = "${version}" )
+package dan200.computercraft.api.media;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/network/IPacketNetwork.java

@@ -3,7 +3,6 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network;
 
 import javax.annotation.Nonnull;
@@ -14,20 +13,21 @@ import javax.annotation.Nonnull;
  * @see Packet
  * @see IPacketReceiver
  */
-public interface IPacketNetwork {
+public interface IPacketNetwork
+{
     /**
      * Add a receiver to the network.
      *
      * @param receiver The receiver to register to the network.
      */
-    void addReceiver(@Nonnull IPacketReceiver receiver);
+    void addReceiver( @Nonnull IPacketReceiver receiver );
 
     /**
      * Remove a receiver from the network.
      *
      * @param receiver The device to remove from the network.
      */
-    void removeReceiver(@Nonnull IPacketReceiver receiver);
+    void removeReceiver( @Nonnull IPacketReceiver receiver );
 
     /**
      * Determine whether this network is wireless.
@@ -37,23 +37,23 @@ public interface IPacketNetwork {
     boolean isWireless();
 
     /**
-     * Submit a packet for transmitting across the network. This will route the packet through the network, sending it to all receivers within range (or any
-     * interdimensional ones).
+     * Submit a packet for transmitting across the network. This will route the packet through the network, sending it
+     * to all receivers within range (or any interdimensional ones).
      *
      * @param packet The packet to send.
-     * @param range The maximum distance this packet will be sent.
+     * @param range  The maximum distance this packet will be sent.
      * @see #transmitInterdimensional(Packet)
      * @see IPacketReceiver#receiveSameDimension(Packet, double)
      */
-    void transmitSameDimension(@Nonnull Packet packet, double range);
+    void transmitSameDimension( @Nonnull Packet packet, double range );
 
     /**
-     * Submit a packet for transmitting across the network. This will route the packet through the network, sending it to all receivers across all
-     * dimensions.
+     * Submit a packet for transmitting across the network. This will route the packet through the network, sending it
+     * to all receivers across all dimensions.
      *
      * @param packet The packet to send.
      * @see #transmitSameDimension(Packet, double)
      * @see IPacketReceiver#receiveDifferentDimension(Packet)
      */
-    void transmitInterdimensional(@Nonnull Packet packet);
+    void transmitInterdimensional( @Nonnull Packet packet );
 }

src/main/java/dan200/computercraft/api/network/IPacketReceiver.java

@@ -3,18 +3,18 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network;
 
-import javax.annotation.Nonnull;
-
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+
 /**
  * An object on an {@link IPacketNetwork}, capable of receiving packets.
  */
-public interface IPacketReceiver {
+public interface IPacketReceiver
+{
     /**
      * Get the world in which this packet receiver exists.
      *
@@ -34,8 +34,9 @@ public interface IPacketReceiver {
     /**
      * Get the maximum distance this receiver can send and receive messages.
      *
-     * When determining whether a receiver can receive a message, the largest distance of the packet and receiver is used - ensuring it is within range. If
-     * the packet or receiver is inter-dimensional, then the packet will always be received.
+     * When determining whether a receiver can receive a message, the largest distance of the packet and receiver is
+     * used - ensuring it is within range. If the packet or receiver is inter-dimensional, then the packet will always
+     * be received.
      *
      * @return The maximum distance this device can send and receive messages.
      * @see #isInterdimensional()
@@ -59,25 +60,25 @@ public interface IPacketReceiver {
     /**
      * Receive a network packet from the same dimension.
      *
-     * @param packet The packet to receive. Generally you should check that you are listening on the given channel and, if so, queue the appropriate
-     *     modem event.
+     * @param packet   The packet to receive. Generally you should check that you are listening on the given channel and,
+     *                 if so, queue the appropriate modem event.
      * @param distance The distance this packet has travelled from the source.
      * @see Packet
      * @see #getRange()
      * @see IPacketNetwork#transmitSameDimension(Packet, double)
      * @see IPacketNetwork#transmitInterdimensional(Packet)
      */
-    void receiveSameDimension(@Nonnull Packet packet, double distance);
+    void receiveSameDimension( @Nonnull Packet packet, double distance );
 
     /**
      * Receive a network packet from a different dimension.
      *
-     * @param packet The packet to receive. Generally you should check that you are listening on the given channel and, if so, queue the appropriate
-     *     modem event.
+     * @param packet The packet to receive. Generally you should check that you are listening on the given channel and,
+     *               if so, queue the appropriate modem event.
      * @see Packet
      * @see IPacketNetwork#transmitInterdimensional(Packet)
      * @see IPacketNetwork#transmitSameDimension(Packet, double)
      * @see #isInterdimensional()
      */
-    void receiveDifferentDimension(@Nonnull Packet packet);
+    void receiveDifferentDimension( @Nonnull Packet packet );
 }

src/main/java/dan200/computercraft/api/network/IPacketSender.java

@@ -3,18 +3,18 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network;
 
-import javax.annotation.Nonnull;
-
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+
 /**
  * An object on a {@link IPacketNetwork}, capable of sending packets.
  */
-public interface IPacketSender {
+public interface IPacketSender
+{
     /**
      * Get the world in which this packet sender exists.
      *
@@ -32,8 +32,8 @@ public interface IPacketSender {
     Vec3d getPosition();
 
     /**
-     * Get some sort of identification string for this sender. This does not strictly need to be unique, but you should be able to extract some identifiable
-     * information from it.
+     * Get some sort of identification string for this sender. This does not strictly need to be unique, but you
+     * should be able to extract some identifiable information from it.
      *
      * @return This device's id.
      */

src/main/java/dan200/computercraft/api/network/Packet.java

@@ -3,13 +3,11 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network;
 
-import java.util.Objects;
-
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import java.util.Objects;
 
 /**
  * Represents a packet which may be sent across a {@link IPacketNetwork}.
@@ -20,7 +18,8 @@ import javax.annotation.Nullable;
  * @see IPacketReceiver#receiveDifferentDimension(Packet)
  * @see IPacketReceiver#receiveSameDimension(Packet, double)
  */
-public class Packet {
+public class Packet
+{
     private final int channel;
     private final int replyChannel;
     private final Object payload;
@@ -30,14 +29,16 @@ public class Packet {
     /**
      * Create a new packet, ready for transmitting across the network.
      *
-     * @param channel The channel to send the packet along. Receiving devices should only process packets from on channels they are listening to.
+     * @param channel      The channel to send the packet along. Receiving devices should only process packets from on
+     *                     channels they are listening to.
      * @param replyChannel The channel to reply on.
-     * @param payload The contents of this packet. This should be a "valid" Lua object, safe for queuing as an event or returning from a peripheral
-     *     call.
-     * @param sender The object which sent this packet.
+     * @param payload      The contents of this packet. This should be a "valid" Lua object, safe for queuing as an
+     *                     event or returning from a peripheral call.
+     * @param sender       The object which sent this packet.
      */
-    public Packet(int channel, int replyChannel, @Nullable Object payload, @Nonnull IPacketSender sender) {
-        Objects.requireNonNull(sender, "sender cannot be null");
+    public Packet( int channel, int replyChannel, @Nullable Object payload, @Nonnull IPacketSender sender )
+    {
+        Objects.requireNonNull( sender, "sender cannot be null" );
 
         this.channel = channel;
         this.replyChannel = replyChannel;
@@ -46,12 +47,14 @@ public class Packet {
     }
 
     /**
-     * Get the channel this packet is sent along. Receivers should generally only process packets from on channels they are listening to.
+     * Get the channel this packet is sent along. Receivers should generally only process packets from on channels they
+     * are listening to.
      *
      * @return This packet's channel.
      */
-    public int getChannel() {
-        return this.channel;
+    public int getChannel()
+    {
+        return channel;
     }
 
     /**
@@ -59,18 +62,21 @@ public class Packet {
      *
      * @return This channel to reply on.
      */
-    public int getReplyChannel() {
-        return this.replyChannel;
+    public int getReplyChannel()
+    {
+        return replyChannel;
     }
 
     /**
-     * The actual data of this packet. This should be a "valid" Lua object, safe for queuing as an event or returning from a peripheral call.
+     * The actual data of this packet. This should be a "valid" Lua object, safe for queuing as an
+     * event or returning from a peripheral call.
      *
      * @return The packet's payload
      */
     @Nullable
-    public Object getPayload() {
-        return this.payload;
+    public Object getPayload()
+    {
+        return payload;
     }
 
     /**
@@ -79,40 +85,33 @@ public class Packet {
      * @return The sending object.
      */
     @Nonnull
-    public IPacketSender getSender() {
-        return this.sender;
+    public IPacketSender getSender()
+    {
+        return sender;
     }
 
     @Override
-    public int hashCode() {
-        int result;
-        result = this.channel;
-        result = 31 * result + this.replyChannel;
-        result = 31 * result + (this.payload != null ? this.payload.hashCode() : 0);
-        result = 31 * result + this.sender.hashCode();
-        return result;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || this.getClass() != o.getClass()) {
-            return false;
-        }
+    public boolean equals( Object o )
+    {
+        if( this == o ) return true;
+        if( o == null || getClass() != o.getClass() ) return false;
 
         Packet packet = (Packet) o;
 
-        if (this.channel != packet.channel) {
-            return false;
-        }
-        if (this.replyChannel != packet.replyChannel) {
-            return false;
-        }
-        if (!Objects.equals(this.payload, packet.payload)) {
-            return false;
-        }
-        return this.sender.equals(packet.sender);
+        if( channel != packet.channel ) return false;
+        if( replyChannel != packet.replyChannel ) return false;
+        if( !Objects.equals( payload, packet.payload ) ) return false;
+        return sender.equals( packet.sender );
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int result;
+        result = channel;
+        result = 31 * result + replyChannel;
+        result = 31 * result + (payload != null ? payload.hashCode() : 0);
+        result = 31 * result + sender.hashCode();
+        return result;
     }
 }

src/main/java/dan200/computercraft/api/network/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Network", apiVersion = "${version}" )
+package dan200.computercraft.api.network;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/network/wired/IWiredElement.java

@@ -3,29 +3,32 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network.wired;
 
-import javax.annotation.Nonnull;
-
 import dan200.computercraft.api.ComputerCraftAPI;
 
+import javax.annotation.Nonnull;
+
 /**
  * An object which may be part of a wired network.
  *
- * Elements should construct a node using {@link ComputerCraftAPI#createWiredNodeForElement(IWiredElement)}. This acts as a proxy for all network objects.
- * Whilst the node may change networks, an element's node should remain constant for its lifespan.
+ * Elements should construct a node using {@link ComputerCraftAPI#createWiredNodeForElement(IWiredElement)}. This acts
+ * as a proxy for all network objects. Whilst the node may change networks, an element's node should remain constant
+ * for its lifespan.
  *
- * Elements are generally tied to a block or tile entity in world. In such as case, one should provide the {@link IWiredElement} capability for the
- * appropriate sides.
+ * Elements are generally tied to a block or tile entity in world. In such as case, one should provide the
+ * {@link IWiredElement} capability for the appropriate sides.
  */
-public interface IWiredElement extends IWiredSender {
+public interface IWiredElement extends IWiredSender
+{
     /**
-     * Called when objects on the network change. This may occur when network nodes are added or removed, or when peripherals change.
+     * Called when objects on the network change. This may occur when network nodes are added or removed, or when
+     * peripherals change.
      *
      * @param change The change which occurred.
      * @see IWiredNetworkChange
      */
-    default void networkChanged(@Nonnull IWiredNetworkChange change) {
+    default void networkChanged( @Nonnull IWiredNetworkChange change )
+    {
     }
 }

src/main/java/dan200/computercraft/api/network/wired/IWiredNetwork.java

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

src/main/java/dan200/computercraft/api/network/wired/IWiredNetworkChange.java

@@ -3,24 +3,23 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network.wired;
 
-import java.util.Map;
+import dan200.computercraft.api.peripheral.IPeripheral;
 
 import javax.annotation.Nonnull;
-
-import dan200.computercraft.api.peripheral.IPeripheral;
+import java.util.Map;
 
 /**
  * Represents a change to the objects on a wired network.
  *
  * @see IWiredElement#networkChanged(IWiredNetworkChange)
  */
-public interface IWiredNetworkChange {
+public interface IWiredNetworkChange
+{
     /**
-     * A set of peripherals which have been removed. Note that there may be entries with the same name in the added and removed set, but with a different
-     * peripheral.
+     * A set of peripherals which have been removed. Note that there may be entries with the same name
+     * in the added and removed set, but with a different peripheral.
      *
      * @return The set of removed peripherals.
      */
@@ -28,8 +27,8 @@ public interface IWiredNetworkChange {
     Map<String, IPeripheral> peripheralsRemoved();
 
     /**
-     * A set of peripherals which have been added. Note that there may be entries with the same name in the added and removed set, but with a different
-     * peripheral.
+     * A set of peripherals which have been added. Note that there may be entries with the same name
+     * in the added and removed set, but with a different peripheral.
      *
      * @return The set of added peripherals.
      */

src/main/java/dan200/computercraft/api/network/wired/IWiredNode.java

@@ -3,29 +3,29 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network.wired;
 
-import java.util.Map;
-
-import javax.annotation.Nonnull;
-
 import dan200.computercraft.api.network.IPacketNetwork;
 import dan200.computercraft.api.peripheral.IPeripheral;
 
+import javax.annotation.Nonnull;
+import java.util.Map;
+
 /**
  * Wired nodes act as a layer between {@link IWiredElement}s and {@link IWiredNetwork}s.
  *
- * Firstly, a node acts as a packet network, capable of sending and receiving modem messages to connected nodes. These methods may be safely used on any
- * thread.
+ * Firstly, a node acts as a packet network, capable of sending and receiving modem messages to connected nodes. These
+ * methods may be safely used on any thread.
  *
- * When sending a packet, the system will attempt to find the shortest path between the two nodes based on their element's position. Note that packet
- * senders and receivers can have different locations from their associated element: the distance between the two will be added to the total packet's
- * distance.
+ * When sending a packet, the system will attempt to find the shortest path between the two nodes based on their
+ * element's position. Note that packet senders and receivers can have different locations from their associated
+ * element: the distance between the two will be added to the total packet's distance.
  *
- * Wired nodes also provide several convenience methods for interacting with a wired network. These should only ever be used on the main server thread.
+ * Wired nodes also provide several convenience methods for interacting with a wired network. These should only ever
+ * be used on the main server thread.
  */
-public interface IWiredNode extends IPacketNetwork {
+public interface IWiredNode extends IPacketNetwork
+{
     /**
      * The associated element for this network node.
      *
@@ -34,6 +34,17 @@ public interface IWiredNode extends IPacketNetwork {
     @Nonnull
     IWiredElement getElement();
 
+    /**
+     * The network this node is currently connected to. Note that this may change
+     * after any network operation, so it should not be cached.
+     *
+     * This should only be used on the server thread.
+     *
+     * @return This node's network.
+     */
+    @Nonnull
+    IWiredNetwork getNetwork();
+
     /**
      * Create a connection from this node to another.
      *
@@ -44,20 +55,11 @@ public interface IWiredNode extends IPacketNetwork {
      * @see IWiredNetwork#connect(IWiredNode, IWiredNode)
      * @see IWiredNode#disconnectFrom(IWiredNode)
      */
-    default boolean connectTo(@Nonnull IWiredNode node) {
-        return this.getNetwork().connect(this, node);
+    default boolean connectTo( @Nonnull IWiredNode node )
+    {
+        return getNetwork().connect( this, node );
     }
 
-    /**
-     * The network this node is currently connected to. Note that this may change after any network operation, so it should not be cached.
-     *
-     * This should only be used on the server thread.
-     *
-     * @return This node's network.
-     */
-    @Nonnull
-    IWiredNetwork getNetwork();
-
     /**
      * Destroy a connection between this node and another.
      *
@@ -69,32 +71,38 @@ public interface IWiredNode extends IPacketNetwork {
      * @see IWiredNetwork#disconnect(IWiredNode, IWiredNode)
      * @see IWiredNode#connectTo(IWiredNode)
      */
-    default boolean disconnectFrom(@Nonnull IWiredNode node) {
-        return this.getNetwork().disconnect(this, node);
+    default boolean disconnectFrom( @Nonnull IWiredNode node )
+    {
+        return getNetwork().disconnect( this, node );
     }
 
     /**
      * Sever all connections this node has, removing it from this network.
      *
-     * This should only be used on the server thread. You should only call this on nodes that your network element owns.
+     * This should only be used on the server thread. You should only call this on nodes
+     * that your network element owns.
      *
-     * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the only element.
+     * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
+     * only element.
      * @throws IllegalArgumentException If the node is not in the network.
      * @see IWiredNetwork#remove(IWiredNode)
      */
-    default boolean remove() {
-        return this.getNetwork().remove(this);
+    default boolean remove()
+    {
+        return getNetwork().remove( this );
     }
 
     /**
      * Mark this node's peripherals as having changed.
      *
-     * This should only be used on the server thread. You should only call this on nodes that your network element owns.
+     * This should only be used on the server thread. You should only call this on nodes
+     * that your network element owns.
      *
      * @param peripherals The new peripherals for this node.
      * @see IWiredNetwork#updatePeripherals(IWiredNode, Map)
      */
-    default void updatePeripherals(@Nonnull Map<String, IPeripheral> peripherals) {
-        this.getNetwork().updatePeripherals(this, peripherals);
+    default void updatePeripherals( @Nonnull Map<String, IPeripheral> peripherals )
+    {
+        getNetwork().updatePeripherals( this, peripherals );
     }
 }

src/main/java/dan200/computercraft/api/network/wired/IWiredSender.java

@@ -3,23 +3,25 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.network.wired;
 
-import javax.annotation.Nonnull;
-
 import dan200.computercraft.api.network.IPacketSender;
 
+import javax.annotation.Nonnull;
+
 /**
  * An object on a {@link IWiredNetwork} capable of sending packets.
  *
- * Unlike a regular {@link IPacketSender}, this must be associated with the node you are attempting to to send the packet from.
+ * Unlike a regular {@link IPacketSender}, this must be associated with the node you are attempting to
+ * to send the packet from.
  */
-public interface IWiredSender extends IPacketSender {
+public interface IWiredSender extends IPacketSender
+{
     /**
      * The node in the network representing this object.
      *
-     * This should be used as a proxy for the main network. One should send packets and register receivers through this object.
+     * This should be used as a proxy for the main network. One should send packets
+     * and register receivers through this object.
      *
      * @return The node for this element.
      */

src/main/java/dan200/computercraft/api/network/wired/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Network|Wired", apiVersion = "${version}" )
+package dan200.computercraft.api.network.wired;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API", apiVersion = "${version}" )
+package dan200.computercraft.api;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/peripheral/IComputerAccess.java

@@ -3,158 +3,166 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.peripheral;
 
-import java.util.Map;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.filesystem.IMount;
 import dan200.computercraft.api.filesystem.IWritableMount;
-import dan200.computercraft.api.lua.ILuaCallback;
 import dan200.computercraft.api.lua.ILuaContext;
 import dan200.computercraft.api.lua.ILuaTask;
-import dan200.computercraft.api.lua.MethodResult;
-
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Collections;
+import java.util.Map;
+
 /**
- * The interface passed to peripherals by computers or turtles, providing methods that they can call. This should not be implemented by your classes. Do not
- * interact with computers except via this interface.
+ * The interface passed to peripherals by computers or turtles, providing methods
+ * that they can call. This should not be implemented by your classes. Do not interact
+ * with computers except via this interface.
  */
-public interface IComputerAccess {
+public interface IComputerAccess
+{
     /**
      * Mount a mount onto the computer's file system in a read only mode.
      *
      * @param desiredLocation The location on the computer's file system where you would like the mount to be mounted.
-     * @param mount The mount object to mount on the computer.
-     * @return The location on the computer's file system where you the mount mounted, or {@code null} if there was already a file in the desired location.
-     *     Store this value if you wish to unmount the mount later.
-     * @throws NotAttachedException If the peripheral has been detached.
+     * @param mount           The mount object to mount on the computer.
+     * @return The location on the computer's file system where you the mount mounted, or {@code null} if there was already a
+     * file in the desired location. Store this value if you wish to unmount the mount later.
+     * @throws RuntimeException If the peripheral has been detached.
      * @see ComputerCraftAPI#createSaveDirMount(World, String, long)
-     * @see ComputerCraftAPI#createResourceMount(String, String)
+     * @see ComputerCraftAPI#createResourceMount(Class, String, String)
      * @see #mount(String, IMount, String)
      * @see #mountWritable(String, IWritableMount)
      * @see #unmount(String)
      * @see IMount
      */
     @Nullable
-    default String mount(@Nonnull String desiredLocation, @Nonnull IMount mount) {
-        return this.mount(desiredLocation, mount, this.getAttachmentName());
+    default String mount( @Nonnull String desiredLocation, @Nonnull IMount mount )
+    {
+        return mount( desiredLocation, mount, getAttachmentName() );
     }
 
     /**
      * Mount a mount onto the computer's file system in a read only mode.
      *
      * @param desiredLocation The location on the computer's file system where you would like the mount to be mounted.
-     * @param mount The mount object to mount on the computer.
-     * @param driveName A custom name to give for this mount location, as returned by {@code fs.getDrive()}.
-     * @return The location on the computer's file system where you the mount mounted, or {@code null} if there was already a file in the desired location.
-     *     Store this value if you wish to unmount the mount later.
-     * @throws NotAttachedException If the peripheral has been detached.
+     * @param mount           The mount object to mount on the computer.
+     * @param driveName       A custom name to give for this mount location, as returned by {@code fs.getDrive()}.
+     * @return The location on the computer's file system where you the mount mounted, or {@code null} if there was already a
+     * file in the desired location. Store this value if you wish to unmount the mount later.
+     * @throws RuntimeException If the peripheral has been detached.
      * @see ComputerCraftAPI#createSaveDirMount(World, String, long)
-     * @see ComputerCraftAPI#createResourceMount(String, String)
+     * @see ComputerCraftAPI#createResourceMount(Class, String, String)
      * @see #mount(String, IMount)
      * @see #mountWritable(String, IWritableMount)
      * @see #unmount(String)
      * @see IMount
      */
     @Nullable
-    String mount(@Nonnull String desiredLocation, @Nonnull IMount mount, @Nonnull String driveName);
-
-    /**
-     * Get a string, unique to the computer, by which the computer refers to this peripheral. For directly attached peripherals this will be
-     * "left","right","front","back",etc, but for peripherals attached remotely it will be different. It is good practice to supply this string when raising
-     * events to the computer, so that the computer knows from which peripheral the event came.
-     *
-     * @return A string unique to the computer, but not globally.
-     * @throws NotAttachedException If the peripheral has been detached.
-     */
-    @Nonnull
-    String getAttachmentName();
+    String mount( @Nonnull String desiredLocation, @Nonnull IMount mount, @Nonnull String driveName );
 
     /**
      * Mount a mount onto the computer's file system in a writable mode.
      *
      * @param desiredLocation The location on the computer's file system where you would like the mount to be mounted.
-     * @param mount The mount object to mount on the computer.
-     * @return The location on the computer's file system where you the mount mounted, or null if there was already a file in the desired location. Store
-     *     this value if you wish to unmount the mount later.
-     * @throws NotAttachedException If the peripheral has been detached.
+     * @param mount           The mount object to mount on the computer.
+     * @return The location on the computer's file system where you the mount mounted, or null if there was already a
+     * file in the desired location. Store this value if you wish to unmount the mount later.
+     * @throws RuntimeException If the peripheral has been detached.
      * @see ComputerCraftAPI#createSaveDirMount(World, String, long)
-     * @see ComputerCraftAPI#createResourceMount(String, String)
+     * @see ComputerCraftAPI#createResourceMount(Class, String, String)
      * @see #mount(String, IMount)
      * @see #unmount(String)
      * @see IMount
      */
     @Nullable
-    default String mountWritable(@Nonnull String desiredLocation, @Nonnull IWritableMount mount) {
-        return this.mountWritable(desiredLocation, mount, this.getAttachmentName());
+    default String mountWritable( @Nonnull String desiredLocation, @Nonnull IWritableMount mount )
+    {
+        return mountWritable( desiredLocation, mount, getAttachmentName() );
     }
 
     /**
      * Mount a mount onto the computer's file system in a writable mode.
      *
      * @param desiredLocation The location on the computer's file system where you would like the mount to be mounted.
-     * @param mount The mount object to mount on the computer.
-     * @param driveName A custom name to give for this mount location, as returned by {@code fs.getDrive()}.
-     * @return The location on the computer's file system where you the mount mounted, or null if there was already a file in the desired location. Store
-     *     this value if you wish to unmount the mount later.
-     * @throws NotAttachedException If the peripheral has been detached.
+     * @param mount           The mount object to mount on the computer.
+     * @param driveName       A custom name to give for this mount location, as returned by {@code fs.getDrive()}.
+     * @return The location on the computer's file system where you the mount mounted, or null if there was already a
+     * file in the desired location. Store this value if you wish to unmount the mount later.
+     * @throws RuntimeException If the peripheral has been detached.
      * @see ComputerCraftAPI#createSaveDirMount(World, String, long)
-     * @see ComputerCraftAPI#createResourceMount(String, String)
+     * @see ComputerCraftAPI#createResourceMount(Class, String, String)
      * @see #mount(String, IMount)
      * @see #unmount(String)
      * @see IMount
      */
-    String mountWritable(@Nonnull String desiredLocation, @Nonnull IWritableMount mount, @Nonnull String driveName);
+    String mountWritable( @Nonnull String desiredLocation, @Nonnull IWritableMount mount, @Nonnull String driveName );
 
     /**
-     * Unmounts a directory previously mounted onto the computers file system by {@link #mount(String, IMount)} or {@link #mountWritable(String,
-     * IWritableMount)}.
+     * Unmounts a directory previously mounted onto the computers file system by {@link #mount(String, IMount)}
+     * or {@link #mountWritable(String, IWritableMount)}.
      *
-     * When a directory is unmounted, it will disappear from the computers file system, and the user will no longer be able to access it. All directories
-     * mounted by a mount or mountWritable are automatically unmounted when the peripheral is attached if they have not been explicitly unmounted.
+     * When a directory is unmounted, it will disappear from the computers file system, and the user will no longer be
+     * able to access it. All directories mounted by a mount or mountWritable are automatically unmounted when the
+     * peripheral is attached if they have not been explicitly unmounted.
      *
      * Note that you cannot unmount another peripheral's mounts.
      *
-     * @param location The desired location in the computers file system of the directory to unmount. This must be the location of a directory
-     *     previously mounted by {@link #mount(String, IMount)} or {@link #mountWritable(String, IWritableMount)}, as indicated by their return value.
-     * @throws NotAttachedException If the peripheral has been detached.
-     * @throws IllegalStateException If the mount does not exist, or was mounted by another peripheral.
+     * @param location The desired location in the computers file system of the directory to unmount.
+     *                 This must be the location of a directory previously mounted by {@link #mount(String, IMount)} or
+     *                 {@link #mountWritable(String, IWritableMount)}, as indicated by their return value.
+     * @throws RuntimeException If the peripheral has been detached.
+     * @throws RuntimeException If the mount does not exist, or was mounted by another peripheral.
      * @see #mount(String, IMount)
      * @see #mountWritable(String, IWritableMount)
      */
-    void unmount(@Nullable String location);
+    void unmount( @Nullable String location );
 
     /**
      * Returns the numerical ID of this computer.
      *
-     * This is the same number obtained by calling {@code os.getComputerID()} or running the "id" program from lua, and is guaranteed unique. This number
-     * will be positive.
+     * This is the same number obtained by calling {@code os.getComputerID()} or running the "id" program from lua,
+     * and is guaranteed unique. This number will be positive.
      *
      * @return The identifier.
      */
     int getID();
 
     /**
-     * Causes an event to be raised on this computer, which the computer can respond to by calling {@code os.pullEvent()}. This can be used to notify the
-     * computer when things happen in the world or to this peripheral.
+     * Causes an event to be raised on this computer, which the computer can respond to by calling
+     * {@code os.pullEvent()}. This can be used to notify the computer when things happen in the world or to
+     * this peripheral.
      *
-     * @param event A string identifying the type of event that has occurred, this will be returned as the first value from {@code os.pullEvent()}. It
-     *     is recommended that you you choose a name that is unique, and recognisable as originating from your peripheral. eg: If your peripheral type is
-     *     "button", a suitable event would be "button_pressed".
-     * @param arguments In addition to a name, you may pass an array of extra arguments to the event, that will be supplied as extra return values to
-     *     os.pullEvent(). Objects in the array will be converted to lua data types in the same fashion as the return values of IPeripheral.callMethod().
+     * @param event     A string identifying the type of event that has occurred, this will be
+     *                  returned as the first value from {@code os.pullEvent()}. It is recommended that you
+     *                  you choose a name that is unique, and recognisable as originating from your
+     *                  peripheral. eg: If your peripheral type is "button", a suitable event would be
+     *                  "button_pressed".
+     * @param arguments In addition to a name, you may pass an array of extra arguments to the event, that will
+     *                  be supplied as extra return values to os.pullEvent(). Objects in the array will be converted
+     *                  to lua data types in the same fashion as the return values of IPeripheral.callMethod().
      *
-     *     You may supply {@code null} to indicate that no arguments are to be supplied.
-     * @throws NotAttachedException If the peripheral has been detached.
-     * @see MethodResult#pullEvent(String, ILuaCallback)
+     *                  You may supply {@code null} to indicate that no arguments are to be supplied.
+     * @throws RuntimeException If the peripheral has been detached.
+     * @see IPeripheral#callMethod
      */
-    void queueEvent(@Nonnull String event, @Nullable Object... arguments);
+    void queueEvent( @Nonnull String event, @Nullable Object[] arguments );
+
+    /**
+     * Get a string, unique to the computer, by which the computer refers to this peripheral.
+     * For directly attached peripherals this will be "left","right","front","back",etc, but
+     * for peripherals attached remotely it will be different. It is good practice to supply
+     * this string when raising events to the computer, so that the computer knows from
+     * which peripheral the event came.
+     *
+     * @return A string unique to the computer, but not globally.
+     * @throws RuntimeException If the peripheral has been detached.
+     */
+    @Nonnull
+    String getAttachmentName();
 
     /**
      * Get a set of peripherals that this computer access can "see", along with their attachment name.
@@ -162,36 +170,45 @@ public interface IComputerAccess {
      * This may include other peripherals on the wired network or peripherals on other sides of the computer.
      *
      * @return All reachable peripherals
-     * @throws NotAttachedException If the peripheral has been detached.
      * @see #getAttachmentName()
      * @see #getAvailablePeripheral(String)
      */
     @Nonnull
-    Map<String, IPeripheral> getAvailablePeripherals();
+    default Map<String, IPeripheral> getAvailablePeripherals()
+    {
+        return Collections.emptyMap();
+    }
 
     /**
-     * Get a reachable peripheral with the given attachment name. This is a equivalent to {@link #getAvailablePeripherals()}{@code .get(name)}, though may
-     * be more efficient.
+     * Get a reachable peripheral with the given attachment name. This is a equivalent to
+     * {@link #getAvailablePeripherals()}{@code .get(name)}, though may be more efficient.
      *
      * @param name The peripheral's attached name
      * @return The reachable peripheral, or {@code null} if none can be found.
      * @see #getAvailablePeripherals()
      */
     @Nullable
-    IPeripheral getAvailablePeripheral(@Nonnull String name);
+    default IPeripheral getAvailablePeripheral( @Nonnull String name )
+    {
+        return null;
+    }
 
     /**
      * Get a {@link IWorkMonitor} for tasks your peripheral might execute on the main (server) thread.
      *
-     * This should be used to ensure your peripheral integrates with ComputerCraft's monitoring and limiting of how much server time each computer consumes.
-     * You should not need to use this if you use {@link ILuaContext#issueMainThreadTask(ILuaTask)} - this is intended for mods with their own system for
-     * running work on the main thread.
+     * This should be used to ensure your peripheral integrates with ComputerCraft's monitoring and limiting of how much
+     * server time each computer consumes. You should not need to use this if you use
+     * {@link ILuaContext#issueMainThreadTask(ILuaTask)} - this is intended for mods with their own system for running
+     * work on the main thread.
      *
-     * Please note that the returned implementation is <em>not</em> thread-safe, and should only be used from the main thread.
+     * Please note that the returned implementation is <em>not</em> thread-safe, and should only be used from the main
+     * thread.
      *
      * @return The work monitor for the main thread, or {@code null} if this computer does not have one.
-     * @throws NotAttachedException If the peripheral has been detached.
      */
-    @Nonnull
-    IWorkMonitor getMainThreadMonitor();
+    @Nullable
+    default IWorkMonitor getMainThreadMonitor()
+    {
+        return null;
+    }
 }

src/main/java/dan200/computercraft/api/peripheral/IDynamicPeripheral.java

@@ -1,53 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.peripheral;
-
-import javax.annotation.Nonnull;
-
-import dan200.computercraft.api.lua.IArguments;
-import dan200.computercraft.api.lua.IDynamicLuaObject;
-import dan200.computercraft.api.lua.ILuaContext;
-import dan200.computercraft.api.lua.LuaException;
-import dan200.computercraft.api.lua.LuaFunction;
-import dan200.computercraft.api.lua.MethodResult;
-
-/**
- * A peripheral whose methods are not known at runtime.
- *
- * This behaves similarly to {@link IDynamicLuaObject}, though also accepting the current {@link IComputerAccess}. Generally one may use {@link LuaFunction}
- * instead of implementing this interface.
- */
-public interface IDynamicPeripheral extends IPeripheral {
-    /**
-     * Should return an array of strings that identify the methods that this peripheral exposes to Lua. This will be called once before each attachment, and
-     * should not change when called multiple times.
-     *
-     * @return An array of strings representing method names.
-     * @see #callMethod
-     */
-    @Nonnull
-    String[] getMethodNames();
-
-    /**
-     * This is called when a lua program on an attached computer calls {@code peripheral.call()} with one of the methods exposed by {@link
-     * #getMethodNames()}.
-     *
-     * Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe when interacting with Minecraft objects.
-     *
-     * @param computer The interface to the computer that is making the call. Remember that multiple computers can be attached to a peripheral at once.
-     * @param context The context of the currently running lua thread. This can be used to wait for events or otherwise yield.
-     * @param method An integer identifying which of the methods from getMethodNames() the computercraft wishes to call. The integer indicates the index
-     *     into the getMethodNames() table that corresponds to the string passed into peripheral.call()
-     * @param arguments The arguments for this method.
-     * @return A {@link MethodResult} containing the values to return or the action to perform.
-     * @throws LuaException If you throw any exception from this function, a lua error will be raised with the same message as your exception. Use this
-     *     to throw appropriate errors if the wrong arguments are supplied to your method.
-     * @see #getMethodNames()
-     */
-    @Nonnull
-    MethodResult callMethod(@Nonnull IComputerAccess computer, @Nonnull ILuaContext context, int method, @Nonnull IArguments arguments) throws LuaException;
-}

src/main/java/dan200/computercraft/api/peripheral/IPeripheral.java

@@ -3,82 +3,143 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.peripheral;
 
+import dan200.computercraft.api.lua.ArgumentHelper;
+import dan200.computercraft.api.lua.ILuaContext;
+import dan200.computercraft.api.lua.LuaException;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-import dan200.computercraft.api.lua.LuaFunction;
-
 /**
- * The interface that defines a peripheral.
- *
- * In order to expose a peripheral for your block or tile entity, you register a {@link IPeripheralProvider}. This <em>cannot</em> be implemented {@link
- * IPeripheral} directly on the tile.
- *
- * Peripherals should provide a series of methods to the user, either using {@link LuaFunction} or by implementing {@link IDynamicPeripheral}.
+ * The interface that defines a peripheral. See {@link IPeripheralProvider} for how to associate blocks with peripherals.
  */
-public interface IPeripheral {
+public interface IPeripheral
+{
     /**
-     * Should return a string that uniquely identifies this type of peripheral. This can be queried from lua by calling {@code peripheral.getType()}
+     * Should return a string that uniquely identifies this type of peripheral.
+     * This can be queried from lua by calling {@code peripheral.getType()}
      *
      * @return A string identifying the type of peripheral.
      */
     @Nonnull
     String getType();
 
+    /**
+     * Should return an array of strings that identify the methods that this
+     * peripheral exposes to Lua. This will be called once before each attachment,
+     * and should not change when called multiple times.
+     *
+     * @return An array of strings representing method names.
+     * @see #callMethod
+     */
+    @Nonnull
+    String[] getMethodNames();
+
+    /**
+     * This is called when a lua program on an attached computer calls {@code peripheral.call()} with
+     * one of the methods exposed by {@link #getMethodNames()}.
+     *
+     * Be aware that this will be called from the ComputerCraft Lua thread, and must be thread-safe when interacting
+     * with Minecraft objects.
+     *
+     * @param computer  The interface to the computer that is making the call. Remember that multiple
+     *                  computers can be attached to a peripheral at once.
+     * @param context   The context of the currently running lua thread. This can be used to wait for events
+     *                  or otherwise yield.
+     * @param method    An integer identifying which of the methods from getMethodNames() the computercraft
+     *                  wishes to call. The integer indicates the index into the getMethodNames() table
+     *                  that corresponds to the string passed into peripheral.call()
+     * @param arguments An array of objects, representing the arguments passed into {@code peripheral.call()}.<br>
+     *                  Lua values of type "string" will be represented by Object type String.<br>
+     *                  Lua values of type "number" will be represented by Object type Double.<br>
+     *                  Lua values of type "boolean" will be represented by Object type Boolean.<br>
+     *                  Lua values of type "table" will be represented by Object type Map.<br>
+     *                  Lua values of any other type will be represented by a null object.<br>
+     *                  This array will be empty if no arguments are passed.
+     *
+     *                  It is recommended you use {@link ArgumentHelper} in order to validate and process arguments.
+     * @return An array of objects, representing values you wish to return to the lua program. Integers, Doubles, Floats,
+     * Strings, Booleans, Maps, ILuaObject and null be converted to their corresponding lua type. All other types will
+     * be converted to nil.
+     *
+     * You may return null to indicate no values should be returned.
+     * @throws LuaException         If you throw any exception from this function, a lua error will be raised with the
+     *                              same message as your exception. Use this to throw appropriate errors if the wrong
+     *                              arguments are supplied to your method.
+     * @throws InterruptedException If the user shuts down or reboots the computer the coroutine is suspended,
+     *                              InterruptedException will be thrown. This exception must not be caught or
+     *                              intercepted, or the computer will leak memory and end up in a broken state.
+     * @see #getMethodNames
+     * @see ArgumentHelper
+     */
+    @Nullable
+    Object[] callMethod( @Nonnull IComputerAccess computer, @Nonnull ILuaContext context, int method, @Nonnull Object[] arguments ) throws LuaException, InterruptedException;
+
     /**
      * Is called when when a computer is attaching to the peripheral.
      *
-     * This will occur when a peripheral is placed next to an active computer, when a computer is turned on next to a peripheral, when a turtle travels into
-     * a square next to a peripheral, or when a wired modem adjacent to this peripheral is does any of the above.
+     * This will occur when a peripheral is placed next to an active computer, when a computer is turned on next to a
+     * peripheral, when a turtle travels into a square next to a peripheral, or when a wired modem adjacent to this
+     * peripheral is does any of the above.
      *
-     * Between calls to attach and {@link #detach}, the attached computer can make method calls on the peripheral using {@code peripheral.call()}. This
-     * method can be used to keep track of which computers are attached to the peripheral, or to take action when attachment occurs.
+     * Between calls to attach and {@link #detach}, the attached computer can make method calls on the peripheral using
+     * {@code peripheral.call()}. This method can be used to keep track of which computers are attached to the
+     * peripheral, or to take action when attachment occurs.
      *
-     * Be aware that will be called from both the server thread and ComputerCraft Lua thread, and so must be thread-safe and reentrant.
+     * Be aware that will be called from both the server thread and ComputerCraft Lua thread, and so must be thread-safe
+     * and reentrant.
      *
-     * @param computer The interface to the computer that is being attached. Remember that multiple computers can be attached to a peripheral at once.
+     * @param computer The interface to the computer that is being attached. Remember that multiple computers can be
+     *                 attached to a peripheral at once.
      * @see #detach
      */
-    default void attach(@Nonnull IComputerAccess computer) {
+    default void attach( @Nonnull IComputerAccess computer )
+    {
     }
 
     /**
      * Called when a computer is detaching from the peripheral.
      *
-     * This will occur when a computer shuts down, when the peripheral is removed while attached to computers, when a turtle moves away from a block
-     * attached to a peripheral, or when a wired modem adjacent to this peripheral is detached.
+     * This will occur when a computer shuts down, when the peripheral is removed while attached to computers, when a
+     * turtle moves away from a block attached to a peripheral, or when a wired modem adjacent to this peripheral is
+     * detached.
      *
-     * This method can be used to keep track of which computers are attached to the peripheral, or to take action when detachment occurs.
+     * This method can be used to keep track of which computers are attached to the peripheral, or to take action when
+     * detachment occurs.
      *
-     * Be aware that this will be called from both the server and ComputerCraft Lua thread, and must be thread-safe and reentrant.
+     * Be aware that this will be called from both the server and ComputerCraft Lua thread, and must be thread-safe
+     * and reentrant.
      *
-     * @param computer The interface to the computer that is being detached. Remember that multiple computers can be attached to a peripheral at once.
+     * @param computer The interface to the computer that is being detached. Remember that multiple computers can be
+     *                 attached to a peripheral at once.
      * @see #attach
      */
-    default void detach(@Nonnull IComputerAccess computer) {
+    default void detach( @Nonnull IComputerAccess computer )
+    {
     }
 
     /**
-     * Get the object that this peripheral provides methods for. This will generally be the tile entity or block, but may be an inventory, entity, etc...
+     * Get the object that this peripheral provides methods for. This will generally be the tile entity
+     * or block, but may be an inventory, entity, etc...
      *
      * @return The object this peripheral targets
      */
-    @Nullable
-    default Object getTarget() {
-        return null;
+    @Nonnull
+    default Object getTarget()
+    {
+        return this;
     }
 
     /**
      * Determine whether this peripheral is equivalent to another one.
      *
-     * The minimal example should at least check whether they are the same object. However, you may wish to check if they point to the same block or tile
-     * entity.
+     * The minimal example should at least check whether they are the same object. However, you may wish to check if
+     * they point to the same block or tile entity.
      *
      * @param other The peripheral to compare against. This may be {@code null}.
      * @return Whether these peripherals are equivalent.
      */
-    boolean equals(@Nullable IPeripheral other);
+    boolean equals( @Nullable IPeripheral other );
 }

src/main/java/dan200/computercraft/api/peripheral/IPeripheralProvider.java

@@ -3,36 +3,35 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.peripheral;
 
-import java.util.Optional;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
 
 import javax.annotation.Nonnull;
-
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.world.World;
+import javax.annotation.Nullable;
 
 /**
  * This interface is used to create peripheral implementations for blocks.
  *
- * If you have a {@link BlockEntity} which acts as a peripheral, you may alternatively expose the {@link IPeripheral} capability.
+ * If you have a {@link TileEntity} which acts as a peripheral, you may alternatively implement {@link IPeripheralTile}.
  *
  * @see dan200.computercraft.api.ComputerCraftAPI#registerPeripheralProvider(IPeripheralProvider)
  */
 @FunctionalInterface
-public interface IPeripheralProvider {
+public interface IPeripheralProvider
+{
     /**
      * Produce an peripheral implementation from a block location.
      *
      * @param world The world the block is in.
-     * @param pos The position the block is at.
-     * @param side The side to get the peripheral from.
-     * @return A peripheral, or {@link Optional#empty()} if there is not a peripheral here you'd like to handle.
+     * @param pos   The position the block is at.
+     * @param side  The side to get the peripheral from.
+     * @return A peripheral, or {@code null} if there is not a peripheral here you'd like to handle.
      * @see dan200.computercraft.api.ComputerCraftAPI#registerPeripheralProvider(IPeripheralProvider)
      */
-    @Nonnull
-    IPeripheral getPeripheral(@Nonnull World world, @Nonnull BlockPos pos, @Nonnull Direction side);
+    @Nullable
+    IPeripheral getPeripheral( @Nonnull World world, @Nonnull BlockPos pos, @Nonnull EnumFacing side );
 }

src/main/java/dan200/computercraft/api/peripheral/IPeripheralTile.java

@@ -1,31 +1,32 @@
 /*
  * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2019. This API may be redistributed unmodified and in full only.
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.peripheral;
 
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.world.World;
-
 /**
- * A {@link net.minecraft.block.entity.BlockEntity} which may act as a peripheral.
+ * A {@link net.minecraft.tileentity.TileEntity} which may act as a peripheral.
  *
- * If you need more complex capabilities (such as handling TEs not belonging to your mod), you should use {@link IPeripheralProvider}.
+ * If you need more complex capabilities (such as handling TEs not belonging to your mod), you should use
+ * {@link IPeripheralProvider}.
  */
-public interface IPeripheralTile {
+public interface IPeripheralTile
+{
     /**
      * Get the peripheral on the given {@code side}.
      *
      * @param side The side to get the peripheral from.
      * @return A peripheral, or {@code null} if there is not a peripheral here.
-     * @see IPeripheralProvider#getPeripheral(World, BlockPos, Direction)
+     * @see IPeripheralProvider#getPeripheral(World, BlockPos, EnumFacing)
      */
     @Nullable
-    IPeripheral getPeripheral(@Nonnull Direction side);
+    IPeripheral getPeripheral( @Nonnull EnumFacing side );
 }

src/main/java/dan200/computercraft/api/peripheral/IWorkMonitor.java

@@ -3,61 +3,29 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.peripheral;
 
+import javax.annotation.Nonnull;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
-import javax.annotation.Nonnull;
-
 /**
- * Monitors "work" associated with a computer, keeping track of how much a computer has done, and ensuring every computer receives a fair share of any
- * processing time.
+ * Monitors "work" associated with a computer, keeping track of how much a computer has done, and ensuring every
+ * computer receives a fair share of any processing time.
  *
- * This is primarily intended for work done by peripherals on the main thread (such as on a tile entity's tick), but could be used for other purposes (such
- * as complex computations done on another thread).
+ * This is primarily intended for work done by peripherals on the main thread (such as on a tile entity's tick), but
+ * could be used for other purposes (such as complex computations done on another thread).
  *
- * Before running a task, one should call {@link #canWork()} to determine if the computer is currently allowed to execute work. If that returns true, you
- * should execute the task and use {@link #trackWork(long, TimeUnit)} to inform the monitor how long that task took.
+ * Before running a task, one should call {@link #canWork()} to determine if the computer is currently allowed to
+ * execute work. If that returns true, you should execute the task and use {@link #trackWork(long, TimeUnit)} to inform
+ * the monitor how long that task took.
  *
  * Alternatively, use {@link #runWork(Runnable)} to run and keep track of work.
  *
  * @see IComputerAccess#getMainThreadMonitor()
  */
-public interface IWorkMonitor {
-    /**
-     * If the owning computer is currently allowed to execute work, and has ample time to do so.
-     *
-     * This is effectively a more restrictive form of {@link #canWork()}. One should use that in order to determine if you may do an initial piece of work,
-     * and shouldWork to determine if any additional task may be performed.
-     *
-     * @return If we should execute work right now.
-     */
-    boolean shouldWork();
-
-    /**
-     * Run a task if possible, and inform the monitor of how long it took.
-     *
-     * @param runnable The task to run.
-     * @return If the task was actually run (namely, {@link #canWork()} returned {@code true}).
-     */
-    default boolean runWork(@Nonnull Runnable runnable) {
-        Objects.requireNonNull(runnable, "runnable should not be null");
-        if (!this.canWork()) {
-            return false;
-        }
-
-        long start = System.nanoTime();
-        try {
-            runnable.run();
-        } finally {
-            this.trackWork(System.nanoTime() - start, TimeUnit.NANOSECONDS);
-        }
-
-        return true;
-    }
-
+public interface IWorkMonitor
+{
     /**
      * If the owning computer is currently allowed to execute work.
      *
@@ -65,11 +33,45 @@ public interface IWorkMonitor {
      */
     boolean canWork();
 
+    /**
+     * If the owning computer is currently allowed to execute work, and has ample time to do so.
+     *
+     * This is effectively a more restrictive form of {@link #canWork()}. One should use that in order to determine if
+     * you may do an initial piece of work, and shouldWork to determine if any additional task may be performed.
+     *
+     * @return If we should execute work right now.
+     */
+    boolean shouldWork();
+
     /**
      * Inform the monitor how long some piece of work took to execute.
      *
      * @param time The time some task took to run
      * @param unit The unit that {@code time} was measured in.
      */
-    void trackWork(long time, @Nonnull TimeUnit unit);
+    void trackWork( long time, @Nonnull TimeUnit unit );
+
+    /**
+     * Run a task if possible, and inform the monitor of how long it took.
+     *
+     * @param runnable The task to run.
+     * @return If the task was actually run (namely, {@link #canWork()} returned {@code true}).
+     */
+    default boolean runWork( @Nonnull Runnable runnable )
+    {
+        Objects.requireNonNull( runnable, "runnable should not be null" );
+        if( !canWork() ) return false;
+
+        long start = System.nanoTime();
+        try
+        {
+            runnable.run();
+        }
+        finally
+        {
+            trackWork( System.nanoTime() - start, TimeUnit.NANOSECONDS );
+        }
+
+        return true;
+    }
 }

src/main/java/dan200/computercraft/api/peripheral/NotAttachedException.java

@@ -1,22 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.peripheral;
-
-/**
- * Thrown when performing operations on {@link IComputerAccess} when the current peripheral is no longer attached to the computer.
- */
-public class NotAttachedException extends IllegalStateException {
-    private static final long serialVersionUID = 1221244785535553536L;
-
-    public NotAttachedException() {
-        super("You are not attached to this computer");
-    }
-
-    public NotAttachedException(String s) {
-        super(s);
-    }
-}

src/main/java/dan200/computercraft/api/peripheral/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Peripheral", apiVersion = "${version}" )
+package dan200.computercraft.api.peripheral;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/permissions/ITurtlePermissionProvider.java

@@ -0,0 +1,41 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.permissions;
+
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import javax.annotation.Nonnull;
+
+/**
+ * This interface is used to restrict where turtles can move or build.
+ *
+ * Turtles will call these methods before attempting to perform an action, allowing them to be cancelled.
+ *
+ * @see dan200.computercraft.api.ComputerCraftAPI#registerPermissionProvider(ITurtlePermissionProvider)
+ */
+public interface ITurtlePermissionProvider
+{
+    /**
+     * Determine whether a block can be entered by a turtle.
+     *
+     * @param world The world the block exists in
+     * @param pos   The location of the block.
+     * @return Whether the turtle can move into this block.
+     */
+    boolean isBlockEnterable( @Nonnull World world, @Nonnull BlockPos pos );
+
+    /**
+     * Determine whether a block can be modified by a turtle.
+     *
+     * This includes breaking and placing blocks.
+     *
+     * @param world The world the block exists in
+     * @param pos   The location of the block.
+     * @return Whether the turtle can modify this block.
+     */
+    boolean isBlockEditable( @Nonnull World world, @Nonnull BlockPos pos );
+}

src/main/java/dan200/computercraft/api/permissions/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Permissions", apiVersion = "${version}" )
+package dan200.computercraft.api.permissions;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/pocket/AbstractPocketUpgrade.java

@@ -3,58 +3,54 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.pocket;
 
-import javax.annotation.Nonnull;
-
-import net.minecraft.item.ItemConvertible;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.Util;
+import net.minecraft.util.ResourceLocation;
+
+import javax.annotation.Nonnull;
 
 /**
  * A base class for {@link IPocketUpgrade}s.
  *
  * One does not have to use this, but it does provide a convenient template.
  */
-public abstract class AbstractPocketUpgrade implements IPocketUpgrade {
-    private final Identifier id;
+public abstract class AbstractPocketUpgrade implements IPocketUpgrade
+{
+    private final ResourceLocation id;
     private final String adjective;
     private final ItemStack stack;
 
-    protected AbstractPocketUpgrade(Identifier id, ItemConvertible item) {
-        this(id, Util.createTranslationKey("upgrade", id) + ".adjective", item);
-    }
-
-    protected AbstractPocketUpgrade(Identifier id, String adjective, ItemConvertible item) {
-        this.id = id;
-        this.adjective = adjective;
-        this.stack = new ItemStack(item);
-    }
-
-    protected AbstractPocketUpgrade(Identifier id, String adjective, ItemStack stack) {
+    protected AbstractPocketUpgrade( ResourceLocation id, String adjective, ItemStack stack )
+    {
         this.id = id;
         this.adjective = adjective;
         this.stack = stack;
     }
 
-
-    @Nonnull
-    @Override
-    public final Identifier getUpgradeID() {
-        return this.id;
+    protected AbstractPocketUpgrade( ResourceLocation id, ItemStack stack )
+    {
+        this( id, "upgrade." + id + ".adjective", stack );
     }
 
     @Nonnull
     @Override
-    public final String getUnlocalisedAdjective() {
-        return this.adjective;
+    public final ResourceLocation getUpgradeID()
+    {
+        return id;
     }
 
     @Nonnull
     @Override
-    public final ItemStack getCraftingItem() {
-        return this.stack;
+    public final String getUnlocalisedAdjective()
+    {
+        return adjective;
+    }
+
+    @Nonnull
+    @Override
+    public final ItemStack getCraftingItem()
+    {
+        return stack;
     }
 }

src/main/java/dan200/computercraft/api/pocket/IPocketAccess.java

@@ -3,38 +3,47 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.pocket;
 
-import java.util.Map;
+import dan200.computercraft.api.peripheral.IPeripheral;
+import net.minecraft.entity.Entity;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-
-import dan200.computercraft.api.peripheral.IPeripheral;
-
-import net.minecraft.entity.Entity;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.util.Identifier;
+import java.util.Map;
 
 /**
  * Wrapper class for pocket computers.
  */
-public interface IPocketAccess {
+public interface IPocketAccess
+{
     /**
      * Gets the entity holding this item.
      *
+     * @return The holding entity. This may be {@code null}.
+     * @deprecated Use {@link #getValidEntity()} where possible.
+     */
+    @Nullable
+    @Deprecated
+    Entity getEntity();
+
+    /**
+     * Gets the entity holding this item with additional safety checks.
+     *
      * This must be called on the server thread.
      *
      * @return The holding entity, or {@code null} if none exists.
      */
     @Nullable
-    Entity getEntity();
+    Entity getValidEntity();
 
     /**
      * Get the colour of this pocket computer as a RGB number.
      *
-     * @return The colour this pocket computer is. This will be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or -1 if it has no colour.
+     * @return The colour this pocket computer is. This will be a RGB colour between {@code 0x000000} and
+     * {@code 0xFFFFFF} or -1 if it has no colour.
      * @see #setColour(int)
      */
     int getColour();
@@ -42,16 +51,17 @@ public interface IPocketAccess {
     /**
      * Set the colour of the pocket computer to a RGB number.
      *
-     * @param colour The colour this pocket computer should be changed to. This should be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or
-     *     -1 to reset to the default colour.
+     * @param colour The colour this pocket computer should be changed to. This should be a RGB colour between
+     *               {@code 0x000000} and {@code 0xFFFFFF} or -1 to reset to the default colour.
      * @see #getColour()
      */
-    void setColour(int colour);
+    void setColour( int colour );
 
     /**
      * Get the colour of this pocket computer's light as a RGB number.
      *
-     * @return The colour this light is. This will be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or -1 if it has no colour.
+     * @return The colour this light is. This will be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or
+     * -1 if it has no colour.
      * @see #setLight(int)
      */
     int getLight();
@@ -59,11 +69,11 @@ public interface IPocketAccess {
     /**
      * Set the colour of the pocket computer's light to a RGB number.
      *
-     * @param colour The colour this modem's light will be changed to. This should be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or -1
-     *     to reset to the default colour.
+     * @param colour The colour this modem's light will be changed to. This should be a RGB colour between
+     *               {@code 0x000000} and {@code 0xFFFFFF} or -1 to reset to the default colour.
      * @see #getLight()
      */
-    void setLight(int colour);
+    void setLight( int colour );
 
     /**
      * Get the upgrade-specific NBT.
@@ -74,7 +84,7 @@ public interface IPocketAccess {
      * @see #updateUpgradeNBTData()
      */
     @Nonnull
-    CompoundTag getUpgradeNBTData();
+    NBTTagCompound getUpgradeNBTData();
 
     /**
      * Mark the upgrade-specific NBT as dirty.
@@ -94,5 +104,5 @@ public interface IPocketAccess {
      * @return A collection of all upgrade names.
      */
     @Nonnull
-    Map<Identifier, IPeripheral> getUpgrades();
+    Map<ResourceLocation, IPeripheral> getUpgrades();
 }

src/main/java/dan200/computercraft/api/pocket/IPocketUpgrade.java

@@ -3,39 +3,39 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.pocket;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.Identifier;
+import net.minecraft.util.ResourceLocation;
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
 /**
  * Additional peripherals for pocket computers.
  *
  * This is similar to {@link ITurtleUpgrade}.
  */
-public interface IPocketUpgrade {
+public interface IPocketUpgrade
+{
 
     /**
-     * Gets a unique identifier representing this type of turtle upgrade. eg: "computercraft:wireless_modem" or "my_mod:my_upgrade".
+     * Gets a unique identifier representing this type of turtle upgrade. eg: "computercraft:wireless_modem" or
+     * "my_mod:my_upgrade".
      *
-     * You should use a unique resource domain to ensure this upgrade is uniquely identified. The upgrade will fail registration if an already used ID is
-     * specified.
+     * You should use a unique resource domain to ensure this upgrade is uniquely identified. The upgrade will fail
+     * registration if an already used ID is specified.
      *
      * @return The upgrade's id.
      * @see IPocketUpgrade#getUpgradeID()
      * @see ComputerCraftAPI#registerPocketUpgrade(IPocketUpgrade)
      */
     @Nonnull
-    Identifier getUpgradeID();
+    ResourceLocation getUpgradeID();
 
     /**
      * Return an unlocalised string to describe the type of pocket computer this upgrade provides.
@@ -49,11 +49,12 @@ public interface IPocketUpgrade {
     String getUnlocalisedAdjective();
 
     /**
-     * Return an item stack representing the type of item that a pocket computer must be crafted with to create a pocket computer which holds this upgrade.
-     * This item stack is also used to determine the upgrade given by {@code pocket.equip()}/{@code pocket.unequip()}.
+     * Return an item stack representing the type of item that a pocket computer must be crafted with to create a
+     * pocket computer which holds this upgrade. This item stack is also used to determine the upgrade given by
+     * {@code pocket.equip()}/{@code pocket.unequip()}.
      *
-     * Ideally this should be constant over a session. It is recommended that you cache the item too, in order to prevent constructing it every time the
-     * method is called.
+     * Ideally this should be constant over a session. It is recommended that you cache
+     * the item too, in order to prevent constructing it every time the method is called.
      *
      * @return The item stack used for crafting. This can be {@link ItemStack#EMPTY} if crafting is disabled.
      */
@@ -63,37 +64,41 @@ public interface IPocketUpgrade {
     /**
      * Creates a peripheral for the pocket computer.
      *
-     * The peripheral created will be stored for the lifetime of the upgrade, will be passed an argument to {@link #update(IPocketAccess, IPeripheral)} and
-     * will be attached, detached and have methods called in the same manner as an ordinary peripheral.
+     * The peripheral created will be stored for the lifetime of the upgrade, will be passed an argument to
+     * {@link #update(IPocketAccess, IPeripheral)} and will be attached, detached and have methods called in the same
+     * manner as an ordinary peripheral.
      *
      * @param access The access object for the pocket item stack.
      * @return The newly created peripheral.
      * @see #update(IPocketAccess, IPeripheral)
      */
     @Nullable
-    IPeripheral createPeripheral(@Nonnull IPocketAccess access);
+    IPeripheral createPeripheral( @Nonnull IPocketAccess access );
 
     /**
      * Called when the pocket computer item stack updates.
      *
-     * @param access The access object for the pocket item stack.
+     * @param access     The access object for the pocket item stack.
      * @param peripheral The peripheral for this upgrade.
      * @see #createPeripheral(IPocketAccess)
      */
-    default void update(@Nonnull IPocketAccess access, @Nullable IPeripheral peripheral) {
+    default void update( @Nonnull IPocketAccess access, @Nullable IPeripheral peripheral )
+    {
     }
 
     /**
      * Called when the pocket computer is right clicked.
      *
-     * @param world The world the computer is in.
-     * @param access The access object for the pocket item stack.
+     * @param world      The world the computer is in.
+     * @param access     The access object for the pocket item stack.
      * @param peripheral The peripheral for this upgrade.
-     * @return {@code true} to stop the GUI from opening, otherwise false. You should always provide some code path which returns {@code false}, such as
-     *     requiring the player to be sneaking - otherwise they will be unable to access the GUI.
+     * @return {@code true} to stop the GUI from opening, otherwise false. You should always provide some code path
+     * which returns {@code false}, such as requiring the player to be sneaking - otherwise they will be unable to
+     * access the GUI.
      * @see #createPeripheral(IPocketAccess)
      */
-    default boolean onRightClick(@Nonnull World world, @Nonnull IPocketAccess access, @Nullable IPeripheral peripheral) {
+    default boolean onRightClick( @Nonnull World world, @Nonnull IPocketAccess access, @Nullable IPeripheral peripheral )
+    {
         return false;
     }
 }

src/main/java/dan200/computercraft/api/redstone/IBundledRedstoneProvider.java

@@ -3,30 +3,31 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.redstone;
 
-import javax.annotation.Nonnull;
-
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
 import net.minecraft.world.World;
 
+import javax.annotation.Nonnull;
+
 /**
  * This interface is used to provide bundled redstone output for blocks.
  *
  * @see dan200.computercraft.api.ComputerCraftAPI#registerBundledRedstoneProvider(IBundledRedstoneProvider)
  */
 @FunctionalInterface
-public interface IBundledRedstoneProvider {
+public interface IBundledRedstoneProvider
+{
     /**
      * Produce an bundled redstone output from a block location.
      *
      * @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 A number in the range 0-65535 to indicate this block is providing output, or -1 if you do not wish to handle this block.
+     * @param pos   The position this block is at.
+     * @param side  The side to extract the bundled redstone output from.
+     * @return A number in the range 0-65535 to indicate this block is providing output, or -1 if you do not wish to
+     * handle this block.
      * @see dan200.computercraft.api.ComputerCraftAPI#registerBundledRedstoneProvider(IBundledRedstoneProvider)
      */
-    int getBundledRedstoneOutput(@Nonnull World world, @Nonnull BlockPos pos, @Nonnull Direction side);
+    int getBundledRedstoneOutput( @Nonnull World world, @Nonnull BlockPos pos, @Nonnull EnumFacing side );
 }

src/main/java/dan200/computercraft/api/redstone/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Redstone", apiVersion = "${version}" )
+package dan200.computercraft.api.redstone;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/turtle/AbstractTurtleUpgrade.java

@@ -1,70 +0,0 @@
-/*
- * This file is part of the public ComputerCraft API - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
-
-import javax.annotation.Nonnull;
-
-import net.minecraft.item.ItemConvertible;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.Util;
-
-/**
- * A base class for {@link ITurtleUpgrade}s.
- *
- * One does not have to use this, but it does provide a convenient template.
- */
-public abstract class AbstractTurtleUpgrade implements ITurtleUpgrade {
-    private final Identifier id;
-    private final TurtleUpgradeType type;
-    private final String adjective;
-    private final ItemStack stack;
-
-    protected AbstractTurtleUpgrade(Identifier id, TurtleUpgradeType type, String adjective, ItemConvertible item) {
-        this(id, type, adjective, new ItemStack(item));
-    }
-
-    protected AbstractTurtleUpgrade(Identifier id, TurtleUpgradeType type, String adjective, ItemStack stack) {
-        this.id = id;
-        this.type = type;
-        this.adjective = adjective;
-        this.stack = stack;
-    }
-
-    protected AbstractTurtleUpgrade(Identifier id, TurtleUpgradeType type, ItemConvertible item) {
-        this(id, type, new ItemStack(item));
-    }
-
-    protected AbstractTurtleUpgrade(Identifier id, TurtleUpgradeType type, ItemStack stack) {
-        this(id, type, Util.createTranslationKey("upgrade", id) + ".adjective", stack);
-    }
-
-
-    @Nonnull
-    @Override
-    public final Identifier getUpgradeID() {
-        return this.id;
-    }
-
-    @Nonnull
-    @Override
-    public final String getUnlocalisedAdjective() {
-        return this.adjective;
-    }
-
-    @Nonnull
-    @Override
-    public final TurtleUpgradeType getType() {
-        return this.type;
-    }
-
-    @Nonnull
-    @Override
-    public final ItemStack getCraftingItem() {
-        return this.stack;
-    }
-}

src/main/java/dan200/computercraft/api/turtle/FakePlayer.java

@@ -1,266 +0,0 @@
-/*
- * This file is part of ComputerCraft - http://www.computercraft.info
- * Copyright Daniel Ratcliffe, 2011-2018. Do not distribute without permission.
- * Send enquiries to dratcliffe@gmail.com
- */
-
-package dan200.computercraft.api.turtle;
-
-import java.util.Collection;
-import java.util.OptionalInt;
-import java.util.UUID;
-
-import javax.annotation.Nullable;
-import javax.crypto.SecretKey;
-
-import com.mojang.authlib.GameProfile;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.util.concurrent.Future;
-import io.netty.util.concurrent.GenericFutureListener;
-
-import net.minecraft.block.entity.CommandBlockBlockEntity;
-import net.minecraft.block.entity.SignBlockEntity;
-import net.minecraft.command.argument.EntityAnchorArgumentType;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.damage.DamageSource;
-import net.minecraft.entity.effect.StatusEffectInstance;
-import net.minecraft.entity.passive.HorseBaseEntity;
-import net.minecraft.inventory.Inventory;
-import net.minecraft.item.ItemStack;
-import net.minecraft.network.ClientConnection;
-import net.minecraft.network.MessageType;
-import net.minecraft.network.NetworkSide;
-import net.minecraft.network.NetworkState;
-import net.minecraft.network.Packet;
-import net.minecraft.network.packet.c2s.play.RequestCommandCompletionsC2SPacket;
-import net.minecraft.network.packet.c2s.play.VehicleMoveC2SPacket;
-import net.minecraft.recipe.Recipe;
-import net.minecraft.screen.NamedScreenHandlerFactory;
-import net.minecraft.screen.ScreenHandler;
-import net.minecraft.server.network.ServerPlayNetworkHandler;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.server.network.ServerPlayerInteractionManager;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.sound.SoundCategory;
-import net.minecraft.sound.SoundEvent;
-import net.minecraft.text.Text;
-import net.minecraft.util.Hand;
-import net.minecraft.util.collection.DefaultedList;
-import net.minecraft.util.math.ChunkPos;
-import net.minecraft.util.math.Vec3d;
-import net.minecraft.village.TraderOfferList;
-import net.minecraft.world.GameMode;
-
-/**
- * A wrapper for {@link ServerPlayerEntity} which denotes a "fake" player.
- *
- * Please note that this does not implement any of the traditional fake player behaviour. It simply exists to prevent me passing in normal players.
- */
-public class FakePlayer extends ServerPlayerEntity {
-    public FakePlayer(ServerWorld world, GameProfile gameProfile) {
-        super(world.getServer(), world, gameProfile, new ServerPlayerInteractionManager(world));
-        this.networkHandler = new FakeNetHandler(this);
-    }
-
-    // region Direct networkHandler access
-    @Override
-    public void enterCombat() { }
-
-    @Override
-    public void endCombat() { }
-
-    @Override
-    public void tick() { }
-
-    @Override
-    public void playerTick() { }
-
-    @Override
-    public void onDeath(DamageSource damage) { }
-
-    @Override
-    public Entity moveToWorld(ServerWorld destination) {
-        return this;
-    }
-
-    @Override
-    public void wakeUp(boolean bl, boolean updateSleepingPlayers) {
-
-    }
-
-    @Override
-    public boolean startRiding(Entity entity, boolean flag) {
-        return false;
-    }
-
-    @Override
-    public void stopRiding() { }
-
-    @Override
-    public void openEditSignScreen(SignBlockEntity tile) { }
-
-    @Override
-    public OptionalInt openHandledScreen(@Nullable NamedScreenHandlerFactory container) {
-        return OptionalInt.empty();
-    }
-
-    @Override
-    public void sendTradeOffers(int id, TraderOfferList list, int level, int experience, boolean levelled, boolean refreshable) { }
-
-    @Override
-    public void openHorseInventory(HorseBaseEntity horse, Inventory inventory) { }
-
-    @Override
-    public void openEditBookScreen(ItemStack stack, Hand hand) { }
-
-    @Override
-    public void openCommandBlockScreen(CommandBlockBlockEntity block) { }
-
-    @Override
-    public void onSlotUpdate(ScreenHandler container, int slot, ItemStack stack) { }
-
-    @Override
-    public void onHandlerRegistered(ScreenHandler container, DefaultedList<ItemStack> defaultedList) { }
-
-    @Override
-    public void onPropertyUpdate(ScreenHandler container, int key, int value) { }
-
-    @Override
-    public void closeHandledScreen() { }
-
-    @Override
-    public void updateCursorStack() { }
-
-    @Override
-    public int unlockRecipes(Collection<Recipe<?>> recipes) {
-        return 0;
-    }
-
-    // Indirect
-    @Override
-    public int lockRecipes(Collection<Recipe<?>> recipes) {
-        return 0;
-    }
-
-    @Override
-    public void sendMessage(Text textComponent, boolean status) { }
-
-    @Override
-    protected void consumeItem() { }
-
-    @Override
-    public void lookAt(EntityAnchorArgumentType.EntityAnchor anchor, Vec3d vec3d) {}
-
-    @Override
-    public void method_14222(EntityAnchorArgumentType.EntityAnchor self, Entity entity, EntityAnchorArgumentType.EntityAnchor target) { }
-
-    @Override
-    protected void onStatusEffectApplied(StatusEffectInstance statusEffectInstance) { }
-
-    @Override
-    protected void onStatusEffectUpgraded(StatusEffectInstance statusEffectInstance, boolean particles) { }
-
-    @Override
-    protected void onStatusEffectRemoved(StatusEffectInstance statusEffectInstance) { }
-
-    @Override
-    public void requestTeleport(double x, double y, double z) { }
-
-    @Override
-    public void setGameMode(GameMode gameMode) { }
-
-    @Override
-    public void sendMessage(Text message, MessageType type, UUID senderUuid) {
-
-    }
-
-    @Override
-    public String getIp() {
-        return "[Fake Player]";
-    }
-
-    @Override
-    public void sendResourcePackUrl(String url, String hash) { }
-
-    @Override
-    public void onStoppedTracking(Entity entity) { }
-
-    @Override
-    public void setCameraEntity(Entity entity) { }
-
-    @Override
-    public void teleport(ServerWorld serverWorld, double x, double y, double z, float pitch, float yaw) { }
-
-    @Override
-    public void sendInitialChunkPackets(ChunkPos chunkPos, Packet<?> packet, Packet<?> packet2) { }
-
-    @Override
-    public void sendUnloadChunkPacket(ChunkPos chunkPos) { }
-
-    @Override
-    public void playSound(SoundEvent soundEvent, SoundCategory soundCategory, float volume, float pitch) { }
-
-    private static class FakeNetHandler extends ServerPlayNetworkHandler {
-        FakeNetHandler(ServerPlayerEntity player) {
-            super(player.server, new FakeConnection(), player);
-        }
-
-        @Override
-        public void disconnect(Text message) { }
-
-        @Override
-        public void onVehicleMove(VehicleMoveC2SPacket move) { }
-
-        @Override
-        public void onRequestCommandCompletions(RequestCommandCompletionsC2SPacket packet) { }
-
-        @Override
-        public void sendPacket(Packet<?> packet, @Nullable GenericFutureListener<? extends Future<? super Void>> listener) { }
-    }
-
-    private static class FakeConnection extends ClientConnection {
-        FakeConnection() {
-            super(NetworkSide.CLIENTBOUND);
-        }
-
-        @Override
-        public void channelActive(ChannelHandlerContext active) {
-        }
-
-        @Override
-        public void setState(NetworkState state) {
-        }
-
-        @Override
-        public void exceptionCaught(ChannelHandlerContext context, Throwable err) {
-        }
-
-        @Override
-        protected void channelRead0(ChannelHandlerContext context, Packet<?> packet) {
-        }
-
-        @Override
-        public void send(Packet<?> packet, @Nullable GenericFutureListener<? extends Future<? super Void>> listener) {
-        }
-
-        @Override
-        public void tick() {
-        }
-
-        @Override
-        public void disconnect(Text message) {
-        }
-
-        @Override
-        public void setupEncryption(SecretKey key) {
-        }
-
-        @Override
-        public void disableAutoRead() {
-        }
-
-        @Override
-        public void setCompressionThreshold(int size) {
-        }
-    }
-}

src/main/java/dan200/computercraft/api/turtle/ITurtleAccess.java

@@ -3,31 +3,31 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
+import com.mojang.authlib.GameProfile;
+import dan200.computercraft.api.lua.ILuaContext;
+import dan200.computercraft.api.lua.LuaException;
+import dan200.computercraft.api.peripheral.IPeripheral;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraftforge.items.IItemHandlerModifiable;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-import com.mojang.authlib.GameProfile;
-import dan200.computercraft.api.lua.ILuaCallback;
-import dan200.computercraft.api.lua.MethodResult;
-import dan200.computercraft.api.peripheral.IPeripheral;
-import dan200.computercraft.shared.util.ItemStorage;
-
-import net.minecraft.inventory.Inventory;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.util.math.Vec3d;
-import net.minecraft.world.World;
-
 /**
  * The interface passed to turtle by turtles, providing methods that they can call.
  *
- * This should not be implemented by your classes. Do not interact with turtles except via this interface and {@link ITurtleUpgrade}.
+ * This should not be implemented by your classes. Do not interact with turtles except via this interface and
+ * {@link ITurtleUpgrade}.
  */
-public interface ITurtleAccess {
+public interface ITurtleAccess
+{
     /**
      * Returns the world in which the turtle resides.
      *
@@ -47,25 +47,28 @@ public interface ITurtleAccess {
     /**
      * Attempt to move this turtle to a new position.
      *
-     * This will preserve the turtle's internal state, such as it's inventory, computer and upgrades. It should be used before playing a movement animation
-     * using {@link #playAnimation(TurtleAnimation)}.
+     * This will preserve the turtle's internal state, such as it's inventory, computer and upgrades. It should
+     * be used before playing a movement animation using {@link #playAnimation(TurtleAnimation)}.
      *
      * @param world The new world to move it to
-     * @param pos The new position to move it to.
-     * @return Whether the movement was successful. It may fail if the block was not loaded or the block placement was cancelled.
+     * @param pos   The new position to move it to.
+     * @return Whether the movement was successful. It may fail if the block was not loaded or the block placement
+     * was cancelled. Note this will not check
+     * {@link dan200.computercraft.api.permissions.ITurtlePermissionProvider#isBlockEnterable(World, BlockPos)}.
      * @throws UnsupportedOperationException When attempting to teleport on the client side.
      */
-    boolean teleportTo(@Nonnull World world, @Nonnull BlockPos pos);
+    boolean teleportTo( @Nonnull World world, @Nonnull BlockPos pos );
 
     /**
-     * Returns a vector containing the floating point co-ordinates at which the turtle is rendered. This will shift when the turtle is moving.
+     * Returns a vector containing the floating point co-ordinates at which the turtle is rendered.
+     * This will shift when the turtle is moving.
      *
      * @param f The subframe fraction.
      * @return A vector containing the floating point co-ordinates at which the turtle resides.
      * @see #getVisualYaw(float)
      */
     @Nonnull
-    Vec3d getVisualPosition(float f);
+    Vec3d getVisualPosition( float f );
 
     /**
      * Returns the yaw the turtle is facing when it is rendered.
@@ -74,25 +77,25 @@ public interface ITurtleAccess {
      * @return The yaw the turtle is facing.
      * @see #getVisualPosition(float)
      */
-    float getVisualYaw(float f);
+    float getVisualYaw( float f );
 
     /**
      * Returns the world direction the turtle is currently facing.
      *
      * @return The world direction the turtle is currently facing.
-     * @see #setDirection(Direction)
+     * @see #setDirection(EnumFacing)
      */
     @Nonnull
-    Direction getDirection();
+    EnumFacing getDirection();
 
     /**
-     * Set the direction the turtle is facing. Note that this will not play a rotation animation, you will also need to call {@link
-     * #playAnimation(TurtleAnimation)} to do so.
+     * Set the direction the turtle is facing. Note that this will not play a rotation animation, you will also need to
+     * call {@link #playAnimation(TurtleAnimation)} to do so.
      *
      * @param dir The new direction to set. This should be on either the x or z axis (so north, south, east or west).
      * @see #getDirection()
      */
-    void setDirection(@Nonnull Direction dir);
+    void setDirection( @Nonnull EnumFacing dir );
 
     /**
      * Get the currently selected slot in the turtle's inventory.
@@ -106,29 +109,31 @@ public interface ITurtleAccess {
     /**
      * Set the currently selected slot in the turtle's inventory.
      *
-     * @param slot The slot to set. This must be greater or equal to 0 and less than the inventory size. Otherwise no action will be taken.
+     * @param slot The slot to set. This must be greater or equal to 0 and less than the inventory size. Otherwise no
+     *             action will be taken.
      * @throws UnsupportedOperationException When attempting to change the slot on the client side.
      * @see #getInventory()
      * @see #getSelectedSlot()
      */
-    void setSelectedSlot(int slot);
-
-    /**
-     * Get the colour of this turtle as a RGB number.
-     *
-     * @return The colour this turtle is. This will be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or -1 if it has no colour.
-     * @see #setColour(int)
-     */
-    int getColour();
+    void setSelectedSlot( int slot );
 
     /**
      * Set the colour of the turtle to a RGB number.
      *
-     * @param colour The colour this turtle should be changed to. This should be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or -1 to
-     *     reset to the default colour.
+     * @param colour The colour this turtle should be changed to. This should be a RGB colour between {@code 0x000000}
+     *               and {@code 0xFFFFFF} or -1 to reset to the default colour.
      * @see #getColour()
      */
-    void setColour(int colour);
+    void setColour( int colour );
+
+    /**
+     * Get the colour of this turtle as a RGB number.
+     *
+     * @return The colour this turtle is. This will be a RGB colour between {@code 0x000000} and {@code 0xFFFFFF} or
+     * -1 if it has no colour.
+     * @see #setColour(int)
+     */
+    int getColour();
 
     /**
      * Get the player who owns this turtle, namely whoever placed it.
@@ -138,6 +143,30 @@ public interface ITurtleAccess {
     @Nonnull
     GameProfile getOwningPlayer();
 
+    /**
+     * Get the inventory of this turtle.
+     *
+     * Note: this inventory should only be accessed and modified on the server thread.
+     *
+     * @return This turtle's inventory
+     * @see #getItemHandler()
+     */
+    @Nonnull
+    IInventory getInventory();
+
+    /**
+     * Get the inventory of this turtle as an {@link IItemHandlerModifiable}.
+     *
+     * Note: this inventory should only be accessed and modified on the server thread.
+     *
+     * @return This turtle's inventory
+     * @see #getInventory()
+     * @see IItemHandlerModifiable
+     * @see net.minecraftforge.items.CapabilityItemHandler#ITEM_HANDLER_CAPABILITY
+     */
+    @Nonnull
+    IItemHandlerModifiable getItemHandler();
+
     /**
      * Determine whether this turtle will require fuel when performing actions.
      *
@@ -157,7 +186,8 @@ public interface ITurtleAccess {
     int getFuelLevel();
 
     /**
-     * Set the fuel level to a new value. It is generally preferred to use {@link #consumeFuel(int)}} or {@link #addFuel(int)} instead.
+     * Set the fuel level to a new value. It is generally preferred to use {@link #consumeFuel(int)}} or {@link #addFuel(int)}
+     * instead.
      *
      * @param fuel The new amount of fuel. This must be between 0 and the fuel limit.
      * @see #getFuelLevel()
@@ -165,7 +195,7 @@ public interface ITurtleAccess {
      * @see #addFuel(int)
      * @see #consumeFuel(int)
      */
-    void setFuelLevel(int fuel);
+    void setFuelLevel( int fuel );
 
     /**
      * Get the maximum amount of fuel a turtle can hold.
@@ -178,11 +208,11 @@ public interface ITurtleAccess {
      * Removes some fuel from the turtles fuel supply. Negative numbers can be passed in to INCREASE the fuel level of the turtle.
      *
      * @param fuel The amount of fuel to consume.
-     * @return Whether the turtle was able to consume the amount of fuel specified. Will return false if you supply a number greater than the current fuel
-     *     level of the turtle. No fuel will be consumed if {@code false} is returned.
+     * @return Whether the turtle was able to consume the amount of fuel specified. Will return false if you supply a number
+     * greater than the current fuel level of the turtle. No fuel will be consumed if {@code false} is returned.
      * @throws UnsupportedOperationException When attempting to consume fuel on the client side.
      */
-    boolean consumeFuel(int fuel);
+    boolean consumeFuel( int fuel );
 
     /**
      * Increase the turtle's fuel level by the given amount.
@@ -190,31 +220,40 @@ public interface ITurtleAccess {
      * @param fuel The amount to refuel with.
      * @throws UnsupportedOperationException When attempting to refuel on the client side.
      */
-    void addFuel(int fuel);
+    void addFuel( int fuel );
 
     /**
-     * Adds a custom command to the turtles command queue. Unlike peripheral methods, these custom commands will be executed on the main thread, so are
-     * guaranteed to be able to access Minecraft objects safely, and will be queued up with the turtles standard movement and tool commands. An issued
-     * command will return an unique integer, which will be supplied as a parameter to a "turtle_response" event issued to the turtle after the command has
-     * completed. Look at the lua source code for "rom/apis/turtle" for how to build a lua wrapper around this functionality.
+     * Adds a custom command to the turtles command queue. Unlike peripheral methods, these custom commands will be executed
+     * on the main thread, so are guaranteed to be able to access Minecraft objects safely, and will be queued up
+     * with the turtles standard movement and tool commands. An issued command will return an unique integer, which will
+     * be supplied as a parameter to a "turtle_response" event issued to the turtle after the command has completed. Look at the
+     * lua source code for "rom/apis/turtle" for how to build a lua wrapper around this functionality.
      *
+     * @param context The Lua context to pull events from.
      * @param command An object which will execute the custom command when its point in the queue is reached
-     * @return The objects the command returned when executed. you should probably return these to the player unchanged if called from a peripheral method.
+     * @return The objects the command returned when executed. you should probably return these to the player
+     * unchanged if called from a peripheral method.
      * @throws UnsupportedOperationException When attempting to execute a command on the client side.
+     * @throws LuaException                  If the user presses CTRL+T to terminate the current program while {@code executeCommand()} is
+     *                                       waiting for an event, a "Terminated" exception will be thrown here.
+     * @throws InterruptedException          If the user shuts down or reboots the computer while pullEvent() is waiting for an
+     *                                       event, InterruptedException will be thrown. This exception must not be caught or
+     *                                       intercepted, or the computer will leak memory and end up in a broken state.
      * @see ITurtleCommand
-     * @see MethodResult#pullEvent(String, ILuaCallback)
+     * @see ILuaContext#pullEvent(String)
      */
     @Nonnull
-    MethodResult executeCommand(@Nonnull ITurtleCommand command);
+    Object[] executeCommand( @Nonnull ILuaContext context, @Nonnull ITurtleCommand command ) throws LuaException, InterruptedException;
 
     /**
-     * Start playing a specific animation. This will prevent other turtle commands from executing until it is finished.
+     * Start playing a specific animation. This will prevent other turtle commands from executing until
+     * it is finished.
      *
      * @param animation The animation to play.
      * @throws UnsupportedOperationException When attempting to execute play an animation on the client side.
      * @see TurtleAnimation
      */
-    void playAnimation(@Nonnull TurtleAnimation animation);
+    void playAnimation( @Nonnull TurtleAnimation animation );
 
     /**
      * Returns the turtle on the specified side of the turtle, if there is one.
@@ -224,16 +263,16 @@ public interface ITurtleAccess {
      * @see #setUpgrade(TurtleSide, ITurtleUpgrade)
      */
     @Nullable
-    ITurtleUpgrade getUpgrade(@Nonnull TurtleSide side);
+    ITurtleUpgrade getUpgrade( @Nonnull TurtleSide side );
 
     /**
      * Set the upgrade for a given side, resetting peripherals and clearing upgrade specific data.
      *
-     * @param side The side to set the upgrade on.
+     * @param side    The side to set the upgrade on.
      * @param upgrade The upgrade to set, may be {@code null} to clear.
      * @see #getUpgrade(TurtleSide)
      */
-    void setUpgrade(@Nonnull TurtleSide side, @Nullable ITurtleUpgrade upgrade);
+    void setUpgrade( @Nonnull TurtleSide side, @Nullable ITurtleUpgrade upgrade );
 
     /**
      * Returns the peripheral created by the upgrade on the specified side of the turtle, if there is one.
@@ -242,40 +281,27 @@ public interface ITurtleAccess {
      * @return The peripheral created by the upgrade on the specified side of the turtle, {@code null} if none exists.
      */
     @Nullable
-    IPeripheral getPeripheral(@Nonnull TurtleSide side);
+    IPeripheral getPeripheral( @Nonnull TurtleSide side );
 
     /**
      * Get an upgrade-specific NBT compound, which can be used to store arbitrary data.
      *
-     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You must call {@link
-     * #updateUpgradeNBTData(TurtleSide)} after modifying it.
+     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You must
+     * call {@link #updateUpgradeNBTData(TurtleSide)} after modifying it.
      *
      * @param side The side to get the upgrade data for.
      * @return The upgrade-specific data.
      * @see #updateUpgradeNBTData(TurtleSide)
      */
     @Nonnull
-    CompoundTag getUpgradeNBTData(@Nullable TurtleSide side);
+    NBTTagCompound getUpgradeNBTData( @Nullable TurtleSide side );
 
     /**
-     * Mark the upgrade-specific data as dirty on a specific side. This is required for the data to be synced to the client and persisted.
+     * Mark the upgrade-specific data as dirty on a specific side. This is required for the data to be synced to the
+     * client and persisted.
      *
      * @param side The side to mark dirty.
      * @see #updateUpgradeNBTData(TurtleSide)
      */
-    void updateUpgradeNBTData(@Nonnull TurtleSide side);
-
-    default ItemStorage getItemHandler() {
-        return ItemStorage.wrap(this.getInventory());
-    }
-
-    /**
-     * Get the inventory of this turtle.
-     *
-     * Note: this inventory should only be accessed and modified on the server thread.
-     *
-     * @return This turtle's inventory
-     */
-    @Nonnull
-    Inventory getInventory();
+    void updateUpgradeNBTData( @Nonnull TurtleSide side );
 }

src/main/java/dan200/computercraft/api/turtle/ITurtleCommand.java

@@ -3,31 +3,33 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
+import dan200.computercraft.api.lua.ILuaContext;
+
 import javax.annotation.Nonnull;
 
 /**
- * An interface for objects executing custom turtle commands, used with {@link ITurtleAccess#executeCommand(ITurtleCommand)}.
+ * An interface for objects executing custom turtle commands, used with {@link ITurtleAccess#executeCommand(ILuaContext, ITurtleCommand)}.
  *
- * @see ITurtleAccess#executeCommand(ITurtleCommand)
+ * @see ITurtleAccess#executeCommand(ILuaContext, ITurtleCommand)
  */
 @FunctionalInterface
-public interface ITurtleCommand {
+public interface ITurtleCommand
+{
     /**
      * Will be called by the turtle on the main thread when it is time to execute the custom command.
      *
-     * The handler should either perform the work of the command, and return success, or return failure with an error message to indicate the command cannot
-     * be executed at this time.
+     * The handler should either perform the work of the command, and return success, or return
+     * failure with an error message to indicate the command cannot be executed at this time.
      *
      * @param turtle Access to the turtle for whom the command was issued.
      * @return A result, indicating whether this action succeeded or not.
-     * @see ITurtleAccess#executeCommand(ITurtleCommand)
+     * @see ITurtleAccess#executeCommand(ILuaContext, ITurtleCommand)
      * @see TurtleCommandResult#success()
      * @see TurtleCommandResult#failure(String)
      * @see TurtleCommandResult
      */
     @Nonnull
-    TurtleCommandResult execute(@Nonnull ITurtleAccess turtle);
+    TurtleCommandResult execute( @Nonnull ITurtleAccess turtle );
 }

src/main/java/dan200/computercraft/api/turtle/ITurtleUpgrade.java

@@ -3,38 +3,56 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
+import dan200.computercraft.api.ComputerCraftAPI;
+import dan200.computercraft.api.peripheral.IPeripheral;
+import dan200.computercraft.api.turtle.event.TurtleAttackEvent;
+import dan200.computercraft.api.turtle.event.TurtleBlockEvent;
+import net.minecraft.client.renderer.block.model.IBakedModel;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.event.entity.player.AttackEntityEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import org.apache.commons.lang3.tuple.Pair;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.client.TransformedModel;
-import dan200.computercraft.api.peripheral.IPeripheral;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.math.Direction;
-
-import net.fabricmc.api.EnvType;
-import net.fabricmc.api.Environment;
+import javax.vecmath.Matrix4f;
 
 /**
- * The primary interface for defining an update for Turtles. A turtle update can either be a new tool, or a new peripheral.
+ * The primary interface for defining an update for Turtles. A turtle update
+ * can either be a new tool, or a new peripheral.
  *
  * @see ComputerCraftAPI#registerTurtleUpgrade(ITurtleUpgrade)
  */
-public interface ITurtleUpgrade {
+public interface ITurtleUpgrade
+{
     /**
-     * Gets a unique identifier representing this type of turtle upgrade. eg: "computercraft:wireless_modem" or "my_mod:my_upgrade". You should use a unique
-     * resource domain to ensure this upgrade is uniquely identified. The turtle will fail registration if an already used ID is specified.
+     * Gets a unique identifier representing this type of turtle upgrade. eg: "computercraft:wireless_modem" or "my_mod:my_upgrade".
+     * You should use a unique resource domain to ensure this upgrade is uniquely identified.
+     * The turtle will fail registration if an already used ID is specified.
      *
      * @return The unique ID for this upgrade.
      * @see ComputerCraftAPI#registerTurtleUpgrade(ITurtleUpgrade)
      */
     @Nonnull
-    Identifier getUpgradeID();
+    ResourceLocation getUpgradeID();
+
+    /**
+     * Gets a numerical identifier representing this type of turtle upgrade,
+     * for backwards compatibility with pre-1.76 worlds. If your upgrade was
+     * not released for older ComputerCraft versions, you can return -1 here.
+     * The turtle will fail registration if an already used positive ID is specified.
+     *
+     * @return The legacy ID, or -1 if is needed.
+     * @see ComputerCraftAPI#registerTurtleUpgrade(ITurtleUpgrade)
+     */
+    int getLegacyUpgradeID();
 
     /**
      * Return an unlocalised string to describe this type of turtle in turtle item names.
@@ -56,11 +74,12 @@ public interface ITurtleUpgrade {
     TurtleUpgradeType getType();
 
     /**
-     * Return an item stack representing the type of item that a turtle must be crafted with to create a turtle which holds this upgrade. This item stack is
-     * also used to determine the upgrade given by {@code turtle.equip()}
+     * Return an item stack representing the type of item that a turtle must be crafted
+     * with to create a turtle which holds this upgrade. This item stack is also used
+     * to determine the upgrade given by {@code turtle.equip()}
      *
-     * Ideally this should be constant over a session. It is recommended that you cache the item too, in order to prevent constructing it every time the
-     * method is called.
+     * Ideally this should be constant over a session. It is recommended that you cache
+     * the item too, in order to prevent constructing it every time the method is called.
      *
      * @return The item stack to craft with, or {@link ItemStack#EMPTY} if it cannot be crafted.
      */
@@ -70,52 +89,68 @@ public interface ITurtleUpgrade {
     /**
      * Will only be called for peripheral upgrades. Creates a peripheral for a turtle being placed using this upgrade.
      *
-     * The peripheral created will be stored for the lifetime of the upgrade and will be passed as an argument to {@link #update(ITurtleAccess,
-     * TurtleSide)}. It will be attached, detached and have methods called in the same manner as a Computer peripheral.
+     * The peripheral created will be stored for the lifetime of the upgrade and will be passed as an argument to
+     * {@link #update(ITurtleAccess, TurtleSide)}. It will be attached, detached and have methods called in the same
+     * manner as a Computer peripheral.
      *
      * @param turtle Access to the turtle that the peripheral is being created for.
-     * @param side Which side of the turtle (left or right) that the upgrade resides on.
-     * @return The newly created peripheral. You may return {@code null} if this upgrade is a Tool and this method is not expected to be called.
+     * @param side   Which side of the turtle (left or right) that the upgrade resides on.
+     * @return The newly created peripheral. You may return {@code null} if this upgrade is a Tool
+     * and this method is not expected to be called.
      */
     @Nullable
-    default IPeripheral createPeripheral(@Nonnull ITurtleAccess turtle, @Nonnull TurtleSide side) {
+    default IPeripheral createPeripheral( @Nonnull ITurtleAccess turtle, @Nonnull TurtleSide side )
+    {
         return null;
     }
 
     /**
-     * Will only be called for Tool turtle. Called when turtle.dig() or turtle.attack() is called by the turtle, and the tool is required to do some work.
+     * Will only be called for Tool turtle. Called when turtle.dig() or turtle.attack() is called
+     * by the turtle, and the tool is required to do some work.
      *
-     * @param turtle Access to the turtle that the tool resides on.
-     * @param side Which side of the turtle (left or right) the tool resides on.
-     * @param verb Which action (dig or attack) the turtle is being called on to perform.
-     * @param direction Which world direction the action should be performed in, relative to the turtles position. This will either be up, down, or the
-     *     direction the turtle is facing, depending on whether dig, digUp or digDown was called.
-     * @return Whether the turtle was able to perform the action, and hence whether the {@code turtle.dig()} or {@code turtle.attack()} lua method should
-     *     return true. If true is returned, the tool will perform a swinging animation. You may return {@code null} if this turtle is a Peripheral  and
-     *     this method is not expected to be called.
+     * Conforming implementations should fire {@link BlockEvent.BreakEvent} and {@link TurtleBlockEvent.Dig} for
+     * digging, {@link AttackEntityEvent} and {@link TurtleAttackEvent} for attacking.
+     *
+     * @param turtle    Access to the turtle that the tool resides on.
+     * @param side      Which side of the turtle (left or right) the tool resides on.
+     * @param verb      Which action (dig or attack) the turtle is being called on to perform.
+     * @param direction Which world direction the action should be performed in, relative to the turtles
+     *                  position. This will either be up, down, or the direction the turtle is facing, depending on
+     *                  whether dig, digUp or digDown was called.
+     * @return Whether the turtle was able to perform the action, and hence whether the {@code turtle.dig()}
+     * or {@code turtle.attack()} lua method should return true. If true is returned, the tool will perform
+     * a swinging animation. You may return {@code null} if this turtle is a Peripheral  and this method is not expected
+     * to be called.
      */
     @Nonnull
-    default TurtleCommandResult useTool(@Nonnull ITurtleAccess turtle, @Nonnull TurtleSide side, @Nonnull TurtleVerb verb, @Nonnull Direction direction) {
+    default TurtleCommandResult useTool( @Nonnull ITurtleAccess turtle, @Nonnull TurtleSide side, @Nonnull TurtleVerb verb, @Nonnull EnumFacing direction )
+    {
         return TurtleCommandResult.failure();
     }
 
     /**
      * Called to obtain the model to be used when rendering a turtle peripheral.
      *
+     * This can be obtained from {@link net.minecraft.client.renderer.ItemModelMesher#getItemModel(ItemStack)},
+     * {@link net.minecraft.client.renderer.block.model.ModelManager#getModel(ModelResourceLocation)} or any other
+     * source.
+     *
      * @param turtle Access to the turtle that the upgrade resides on. This will be null when getting item models!
-     * @param side Which side of the turtle (left or right) the upgrade resides on.
-     * @return The model that you wish to be used to render your upgrade.
+     * @param side   Which side of the turtle (left or right) the upgrade resides on.
+     * @return The model that you wish to be used to render your upgrade, and a transformation to apply to it. Returning
+     * a transformation of {@code null} has the same effect as the identify matrix.
      */
     @Nonnull
-    @Environment (EnvType.CLIENT)
-    TransformedModel getModel(@Nullable ITurtleAccess turtle, @Nonnull TurtleSide side);
+    @SideOnly( Side.CLIENT )
+    Pair<IBakedModel, Matrix4f> getModel( @Nullable ITurtleAccess turtle, @Nonnull TurtleSide side );
 
     /**
      * Called once per tick for each turtle which has the upgrade equipped.
      *
      * @param turtle Access to the turtle that the upgrade resides on.
-     * @param side Which side of the turtle (left or right) the upgrade resides on.
+     * @param side   Which side of the turtle (left or right) the upgrade resides on.
      */
-    default void update(@Nonnull ITurtleAccess turtle, @Nonnull TurtleSide side) {
+    default void update( @Nonnull ITurtleAccess turtle, @Nonnull TurtleSide side )
+    {
     }
 }

src/main/java/dan200/computercraft/api/turtle/TurtleAnimation.java

@@ -3,7 +3,6 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
 /**
@@ -13,70 +12,75 @@ package dan200.computercraft.api.turtle;
  *
  * @see ITurtleAccess#playAnimation(TurtleAnimation)
  */
-public enum TurtleAnimation {
+public enum TurtleAnimation
+{
     /**
      * An animation which does nothing. This takes no time to complete.
      *
-     * @see #WAIT
-     * @see #SHORT_WAIT
+     * @see #Wait
+     * @see #ShortWait
      */
-    NONE,
+    None,
 
     /**
-     * Make the turtle move forward. Note that the animation starts from the block <em>behind</em> it, and moves into this one.
+     * Make the turtle move forward. Note that the animation starts from the block <em>behind</em> it, and
+     * moves into this one.
      */
-    MOVE_FORWARD,
+    MoveForward,
 
     /**
-     * Make the turtle move backwards. Note that the animation starts from the block <em>in front</em> it, and moves into this one.
+     * Make the turtle move backwards. Note that the animation starts from the block <em>in front</em> it, and
+     * moves into this one.
      */
-    MOVE_BACK,
+    MoveBack,
 
     /**
-     * Make the turtle move backwards. Note that the animation starts from the block <em>above</em> it, and moves into this one.
+     * Make the turtle move backwards. Note that the animation starts from the block <em>above</em> it, and
+     * moves into this one.
      */
-    MOVE_UP,
+    MoveUp,
 
     /**
-     * Make the turtle move backwards. Note that the animation starts from the block <em>below</em> it, and moves into this one.
+     * Make the turtle move backwards. Note that the animation starts from the block <em>below</em> it, and
+     * moves into this one.
      */
-    MOVE_DOWN,
+    MoveDown,
 
     /**
-     * Turn the turtle to the left. Note that the animation starts with the turtle facing <em>right</em>, and the turtle turns to face in the current
-     * direction.
+     * Turn the turtle to the left. Note that the animation starts with the turtle facing <em>right</em>, and
+     * the turtle turns to face in the current direction.
      */
-    TURN_LEFT,
+    TurnLeft,
 
     /**
-     * Turn the turtle to the left. Note that the animation starts with the turtle facing <em>right</em>, and the turtle turns to face in the current
-     * direction.
+     * Turn the turtle to the left. Note that the animation starts with the turtle facing <em>right</em>, and
+     * the turtle turns to face in the current direction.
      */
-    TURN_RIGHT,
+    TurnRight,
 
     /**
      * Swing the tool on the left.
      */
-    SWING_LEFT_TOOL,
+    SwingLeftTool,
 
     /**
      * Swing the tool on the right.
      */
-    SWING_RIGHT_TOOL,
+    SwingRightTool,
 
     /**
      * Wait until the animation has finished, performing no movement.
      *
-     * @see #SHORT_WAIT
-     * @see #NONE
+     * @see #ShortWait
+     * @see #None
      */
-    WAIT,
+    Wait,
 
     /**
      * Wait until the animation has finished, performing no movement. This takes 4 ticks to complete.
      *
-     * @see #WAIT
-     * @see #NONE
+     * @see #Wait
+     * @see #None
      */
-    SHORT_WAIT,
+    ShortWait,
 }

src/main/java/dan200/computercraft/api/turtle/TurtleCommandResult.java

@@ -3,9 +3,10 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
+import net.minecraft.util.EnumFacing;
+
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
@@ -13,20 +14,12 @@ import javax.annotation.Nullable;
  * Used to indicate the result of executing a turtle command.
  *
  * @see ITurtleCommand#execute(ITurtleAccess)
- * @see ITurtleUpgrade#useTool(ITurtleAccess, TurtleSide, TurtleVerb, Direction)
+ * @see ITurtleUpgrade#useTool(ITurtleAccess, TurtleSide, TurtleVerb, EnumFacing)
  */
-public final class TurtleCommandResult {
-    private static final TurtleCommandResult EMPTY_SUCCESS = new TurtleCommandResult(true, null, null);
-    private static final TurtleCommandResult EMPTY_FAILURE = new TurtleCommandResult(false, null, null);
-    private final boolean success;
-    private final String errorMessage;
-    private final Object[] results;
-
-    private TurtleCommandResult(boolean success, String errorMessage, Object[] results) {
-        this.success = success;
-        this.errorMessage = errorMessage;
-        this.results = results;
-    }
+public final class TurtleCommandResult
+{
+    private static final TurtleCommandResult EMPTY_SUCCESS = new TurtleCommandResult( true, null, null );
+    private static final TurtleCommandResult EMPTY_FAILURE = new TurtleCommandResult( false, null, null );
 
     /**
      * Create a successful command result with no result.
@@ -34,7 +27,8 @@ public final class TurtleCommandResult {
      * @return A successful command result with no values.
      */
     @Nonnull
-    public static TurtleCommandResult success() {
+    public static TurtleCommandResult success()
+    {
         return EMPTY_SUCCESS;
     }
 
@@ -45,11 +39,10 @@ public final class TurtleCommandResult {
      * @return A successful command result with the given values.
      */
     @Nonnull
-    public static TurtleCommandResult success(@Nullable Object[] results) {
-        if (results == null || results.length == 0) {
-            return EMPTY_SUCCESS;
-        }
-        return new TurtleCommandResult(true, null, results);
+    public static TurtleCommandResult success( @Nullable Object[] results )
+    {
+        if( results == null || results.length == 0 ) return EMPTY_SUCCESS;
+        return new TurtleCommandResult( true, null, results );
     }
 
     /**
@@ -58,7 +51,8 @@ public final class TurtleCommandResult {
      * @return A failed command result with no message.
      */
     @Nonnull
-    public static TurtleCommandResult failure() {
+    public static TurtleCommandResult failure()
+    {
         return EMPTY_FAILURE;
     }
 
@@ -69,11 +63,21 @@ public final class TurtleCommandResult {
      * @return A failed command result with a message.
      */
     @Nonnull
-    public static TurtleCommandResult failure(@Nullable String errorMessage) {
-        if (errorMessage == null) {
-            return EMPTY_FAILURE;
-        }
-        return new TurtleCommandResult(false, errorMessage, null);
+    public static TurtleCommandResult failure( @Nullable String errorMessage )
+    {
+        if( errorMessage == null ) return EMPTY_FAILURE;
+        return new TurtleCommandResult( false, errorMessage, null );
+    }
+
+    private final boolean success;
+    private final String errorMessage;
+    private final Object[] results;
+
+    private TurtleCommandResult( boolean success, String errorMessage, Object[] results )
+    {
+        this.success = success;
+        this.errorMessage = errorMessage;
+        this.results = results;
     }
 
     /**
@@ -81,8 +85,9 @@ public final class TurtleCommandResult {
      *
      * @return If the command was successful.
      */
-    public boolean isSuccess() {
-        return this.success;
+    public boolean isSuccess()
+    {
+        return success;
     }
 
     /**
@@ -91,8 +96,9 @@ public final class TurtleCommandResult {
      * @return The command's error message, or {@code null} if it was a success.
      */
     @Nullable
-    public String getErrorMessage() {
-        return this.errorMessage;
+    public String getErrorMessage()
+    {
+        return errorMessage;
     }
 
     /**
@@ -101,7 +107,8 @@ public final class TurtleCommandResult {
      * @return The command's result, or {@code null} if it was a failure.
      */
     @Nullable
-    public Object[] getResults() {
-        return this.results;
+    public Object[] getResults()
+    {
+        return results;
     }
 }

src/main/java/dan200/computercraft/api/turtle/TurtleSide.java

@@ -3,20 +3,20 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
 /**
  * An enum representing the two sides of the turtle that a turtle turtle might reside.
  */
-public enum TurtleSide {
+public enum TurtleSide
+{
     /**
      * The turtle's left side (where the pickaxe usually is on a Wireless Mining Turtle).
      */
-    LEFT,
+    Left,
 
     /**
      * The turtle's right side (where the modem usually is on a Wireless Mining Turtle).
      */
-    RIGHT,
+    Right,
 }

src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeType.java

@@ -3,7 +3,6 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
 /**
@@ -11,30 +10,34 @@ package dan200.computercraft.api.turtle;
  *
  * @see ITurtleUpgrade#getType()
  */
-public enum TurtleUpgradeType {
+public enum TurtleUpgradeType
+{
     /**
-     * A tool is rendered as an item on the side of the turtle, and responds to the {@code turtle.dig()} and {@code turtle.attack()} methods (Such as
-     * pickaxe or sword on Mining and Melee turtles).
+     * A tool is rendered as an item on the side of the turtle, and responds to the {@code turtle.dig()}
+     * and {@code turtle.attack()} methods (Such as pickaxe or sword on Mining and Melee turtles).
      */
-    TOOL,
+    Tool,
 
     /**
-     * A peripheral adds a special peripheral which is attached to the side of the turtle, and can be interacted with the {@code peripheral} API (Such as
-     * the modem on Wireless Turtles).
+     * A peripheral adds a special peripheral which is attached to the side of the turtle,
+     * and can be interacted with the {@code peripheral} API (Such as the modem on Wireless Turtles).
      */
-    PERIPHERAL,
+    Peripheral,
 
     /**
-     * An upgrade which provides both a tool and a peripheral. This can be used when you wish your upgrade to also provide methods. For example, a pickaxe
-     * could provide methods determining whether it can break the given block or not.
+     * An upgrade which provides both a tool and a peripheral. This can be used when you wish
+     * your upgrade to also provide methods. For example, a pickaxe could provide methods
+     * determining whether it can break the given block or not.
      */
-    BOTH;
+    Both;
 
-    public boolean isTool() {
-        return this == TOOL || this == BOTH;
+    public boolean isTool()
+    {
+        return this == Tool || this == Both;
     }
 
-    public boolean isPeripheral() {
-        return this == PERIPHERAL || this == BOTH;
+    public boolean isPeripheral()
+    {
+        return this == Peripheral || this == Both;
     }
 }

src/main/java/dan200/computercraft/api/turtle/TurtleVerb.java

@@ -3,23 +3,26 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle;
 
+import net.minecraft.util.EnumFacing;
+
 /**
- * An enum representing the different actions that an {@link ITurtleUpgrade} of type Tool may be called on to perform by a turtle.
+ * An enum representing the different actions that an {@link ITurtleUpgrade} of type Tool may be called on to perform by
+ * a turtle.
  *
  * @see ITurtleUpgrade#getType()
- * @see ITurtleUpgrade#useTool(ITurtleAccess, TurtleSide, TurtleVerb, Direction)
+ * @see ITurtleUpgrade#useTool(ITurtleAccess, TurtleSide, TurtleVerb, EnumFacing)
  */
-public enum TurtleVerb {
+public enum TurtleVerb
+{
     /**
      * The turtle called {@code turtle.dig()}, {@code turtle.digUp()} or {@code turtle.digDown()}.
      */
-    DIG,
+    Dig,
 
     /**
      * The turtle called {@code turtle.attack()}, {@code turtle.attackUp()} or {@code turtle.attackDown()}.
      */
-    ATTACK,
+    Attack,
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtleAction.java

@@ -3,7 +3,6 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
 /**
@@ -11,7 +10,8 @@ package dan200.computercraft.api.turtle.event;
  *
  * @see TurtleActionEvent
  */
-public enum TurtleAction {
+public enum TurtleAction
+{
     /**
      * A turtle moves to a new position.
      *

src/main/java/dan200/computercraft/api/turtle/event/TurtleActionEvent.java

@@ -3,34 +3,36 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Objects;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.TurtleCommandResult;
+import net.minecraftforge.fml.common.eventhandler.Cancelable;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Objects;
 
 /**
  * An event fired when a turtle is performing a known action.
  */
-public class TurtleActionEvent extends TurtleEvent {
+@Cancelable
+public class TurtleActionEvent extends TurtleEvent
+{
     private final TurtleAction action;
     private String failureMessage;
-    private boolean cancelled = false;
 
-    public TurtleActionEvent(@Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action) {
-        super(turtle);
+    public TurtleActionEvent( @Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action )
+    {
+        super( turtle );
 
-        Objects.requireNonNull(action, "action cannot be null");
+        Objects.requireNonNull( action, "action cannot be null" );
         this.action = action;
     }
 
-    public TurtleAction getAction() {
-        return this.action;
+    public TurtleAction getAction()
+    {
+        return action;
     }
 
     /**
@@ -42,9 +44,11 @@ public class TurtleActionEvent extends TurtleEvent {
      * @see TurtleCommandResult#failure()
      * @deprecated Use {@link #setCanceled(boolean, String)} instead.
      */
+    @Override
     @Deprecated
-    public void setCanceled(boolean cancel) {
-        this.setCanceled(cancel, null);
+    public void setCanceled( boolean cancel )
+    {
+        setCanceled( cancel, null );
     }
 
     /**
@@ -52,12 +56,13 @@ public class TurtleActionEvent extends TurtleEvent {
      *
      * If {@code cancel} is {@code true}, this action will not be carried out.
      *
-     * @param cancel The new canceled value.
+     * @param cancel         The new canceled value.
      * @param failureMessage The message to return to the user explaining the failure.
      * @see TurtleCommandResult#failure(String)
      */
-    public void setCanceled(boolean cancel, @Nullable String failureMessage) {
-        this.cancelled = true;
+    public void setCanceled( boolean cancel, @Nullable String failureMessage )
+    {
+        super.setCanceled( cancel );
         this.failureMessage = cancel ? failureMessage : null;
     }
 
@@ -69,11 +74,8 @@ public class TurtleActionEvent extends TurtleEvent {
      * @see #setCanceled(boolean, String)
      */
     @Nullable
-    public String getFailureMessage() {
-        return this.failureMessage;
-    }
-
-    public boolean isCancelled() {
-        return this.cancelled;
+    public String getFailureMessage()
+    {
+        return failureMessage;
     }
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtleAttackEvent.java

@@ -3,36 +3,42 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Objects;
-
-import javax.annotation.Nonnull;
-
-import dan200.computercraft.api.turtle.FakePlayer;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-
+import dan200.computercraft.api.turtle.TurtleVerb;
 import net.minecraft.entity.Entity;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.common.util.FakePlayer;
+import net.minecraftforge.event.entity.player.AttackEntityEvent;
+
+import javax.annotation.Nonnull;
+import java.util.Objects;
 
 /**
  * Fired when a turtle attempts to attack an entity.
  *
+ * This must be fired by {@link ITurtleUpgrade#useTool(ITurtleAccess, TurtleSide, TurtleVerb, EnumFacing)},
+ * as the base {@code turtle.attack()} command does not fire it.
+ *
+ * Note that such commands should also fire {@link AttackEntityEvent}, so you do not need to listen to both.
+ *
  * @see TurtleAction#ATTACK
  */
-public class TurtleAttackEvent extends TurtlePlayerEvent {
+public class TurtleAttackEvent extends TurtlePlayerEvent
+{
     private final Entity target;
     private final ITurtleUpgrade upgrade;
     private final TurtleSide side;
 
-    public TurtleAttackEvent(@Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull Entity target, @Nonnull ITurtleUpgrade upgrade,
-                             @Nonnull TurtleSide side) {
-        super(turtle, TurtleAction.ATTACK, player);
-        Objects.requireNonNull(target, "target cannot be null");
-        Objects.requireNonNull(upgrade, "upgrade cannot be null");
-        Objects.requireNonNull(side, "side cannot be null");
+    public TurtleAttackEvent( @Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull Entity target, @Nonnull ITurtleUpgrade upgrade, @Nonnull TurtleSide side )
+    {
+        super( turtle, TurtleAction.ATTACK, player );
+        Objects.requireNonNull( target, "target cannot be null" );
+        Objects.requireNonNull( upgrade, "upgrade cannot be null" );
+        Objects.requireNonNull( side, "side cannot be null" );
         this.target = target;
         this.upgrade = upgrade;
         this.side = side;
@@ -44,8 +50,9 @@ public class TurtleAttackEvent extends TurtlePlayerEvent {
      * @return The entity being attacked.
      */
     @Nonnull
-    public Entity getTarget() {
-        return this.target;
+    public Entity getTarget()
+    {
+        return target;
     }
 
     /**
@@ -54,8 +61,9 @@ public class TurtleAttackEvent extends TurtlePlayerEvent {
      * @return The upgrade responsible for attacking.
      */
     @Nonnull
-    public ITurtleUpgrade getUpgrade() {
-        return this.upgrade;
+    public ITurtleUpgrade getUpgrade()
+    {
+        return upgrade;
     }
 
     /**
@@ -64,7 +72,8 @@ public class TurtleAttackEvent extends TurtlePlayerEvent {
      * @return The upgrade's side.
      */
     @Nonnull
-    public TurtleSide getSide() {
-        return this.side;
+    public TurtleSide getSide()
+    {
+        return side;
     }
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtleBlockEvent.java

@@ -3,44 +3,49 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Map;
-import java.util.Objects;
-
-import javax.annotation.Nonnull;
-
-import dan200.computercraft.api.lua.MethodResult;
-import dan200.computercraft.api.turtle.FakePlayer;
+import dan200.computercraft.api.lua.ILuaContext;
+import dan200.computercraft.api.peripheral.IComputerAccess;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-
-import net.minecraft.block.BlockState;
+import dan200.computercraft.api.turtle.TurtleVerb;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.FakePlayer;
+import net.minecraftforge.event.world.BlockEvent;
+
+import javax.annotation.Nonnull;
+import java.util.Map;
+import java.util.Objects;
 
 /**
  * A general event for when a turtle interacts with a block or region.
  *
- * You should generally listen to one of the sub-events instead, cancelling them where appropriate.
+ * You should generally listen to one of the sub-events instead, cancelling them where
+ * appropriate.
  *
- * Note that you are not guaranteed to receive this event, if it has been cancelled by other mechanisms, such as block protection systems.
+ * Note that you are not guaranteed to receive this event, if it has been cancelled by other
+ * mechanisms, such as block protection systems.
  *
- * Be aware that some events (such as {@link TurtleInventoryEvent}) do not necessarily interact with a block, simply objects within that block space.
+ * Be aware that some events (such as {@link TurtleInventoryEvent}) do not necessarily interact
+ * with a block, simply objects within that block space.
  */
-public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
+public abstract class TurtleBlockEvent extends TurtlePlayerEvent
+{
     private final World world;
     private final BlockPos pos;
 
-    protected TurtleBlockEvent(@Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action, @Nonnull FakePlayer player, @Nonnull World world,
-                               @Nonnull BlockPos pos) {
-        super(turtle, action, player);
+    protected TurtleBlockEvent( @Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos )
+    {
+        super( turtle, action, player );
 
-        Objects.requireNonNull(world, "world cannot be null");
-        Objects.requireNonNull(pos, "pos cannot be null");
+        Objects.requireNonNull( world, "world cannot be null" );
+        Objects.requireNonNull( pos, "pos cannot be null" );
         this.world = world;
         this.pos = pos;
     }
@@ -50,36 +55,45 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
      *
      * @return The world the turtle is interacting in.
      */
-    public World getWorld() {
-        return this.world;
+    public World getWorld()
+    {
+        return world;
     }
 
     /**
-     * Get the position the turtle is interacting with. Note that this is different to {@link ITurtleAccess#getPosition()}.
+     * Get the position the turtle is interacting with. Note that this is different
+     * to {@link ITurtleAccess#getPosition()}.
      *
      * @return The position the turtle is interacting with.
      */
-    public BlockPos getPos() {
-        return this.pos;
+    public BlockPos getPos()
+    {
+        return pos;
     }
 
     /**
      * Fired when a turtle attempts to dig a block.
      *
+     * This must be fired by {@link ITurtleUpgrade#useTool(ITurtleAccess, TurtleSide, TurtleVerb, EnumFacing)},
+     * as the base {@code turtle.dig()} command does not fire it.
+     *
+     * Note that such commands should also fire {@link BlockEvent.BreakEvent}, so you do not need to listen to both.
+     *
      * @see TurtleAction#DIG
      */
-    public static class Dig extends TurtleBlockEvent {
-        private final BlockState block;
+    public static class Dig extends TurtleBlockEvent
+    {
+        private final IBlockState block;
         private final ITurtleUpgrade upgrade;
         private final TurtleSide side;
 
-        public Dig(@Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull BlockState block,
-                   @Nonnull ITurtleUpgrade upgrade, @Nonnull TurtleSide side) {
-            super(turtle, TurtleAction.DIG, player, world, pos);
+        public Dig( @Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull IBlockState block, @Nonnull ITurtleUpgrade upgrade, @Nonnull TurtleSide side )
+        {
+            super( turtle, TurtleAction.DIG, player, world, pos );
 
-            Objects.requireNonNull(block, "block cannot be null");
-            Objects.requireNonNull(upgrade, "upgrade cannot be null");
-            Objects.requireNonNull(side, "side cannot be null");
+            Objects.requireNonNull( block, "block cannot be null" );
+            Objects.requireNonNull( upgrade, "upgrade cannot be null" );
+            Objects.requireNonNull( side, "side cannot be null" );
             this.block = block;
             this.upgrade = upgrade;
             this.side = side;
@@ -91,8 +105,9 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
          * @return The block which is going to be broken.
          */
         @Nonnull
-        public BlockState getBlock() {
-            return this.block;
+        public IBlockState getBlock()
+        {
+            return block;
         }
 
         /**
@@ -101,8 +116,9 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
          * @return The upgrade doing the digging.
          */
         @Nonnull
-        public ITurtleUpgrade getUpgrade() {
-            return this.upgrade;
+        public ITurtleUpgrade getUpgrade()
+        {
+            return upgrade;
         }
 
         /**
@@ -111,8 +127,9 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
          * @return The upgrade's side.
          */
         @Nonnull
-        public TurtleSide getSide() {
-            return this.side;
+        public TurtleSide getSide()
+        {
+            return side;
         }
     }
 
@@ -121,9 +138,11 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
      *
      * @see TurtleAction#MOVE
      */
-    public static class Move extends TurtleBlockEvent {
-        public Move(@Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos) {
-            super(turtle, TurtleAction.MOVE, player, world, pos);
+    public static class Move extends TurtleBlockEvent
+    {
+        public Move( @Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos )
+        {
+            super( turtle, TurtleAction.MOVE, player, world, pos );
         }
     }
 
@@ -132,13 +151,15 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
      *
      * @see TurtleAction#PLACE
      */
-    public static class Place extends TurtleBlockEvent {
+    public static class Place extends TurtleBlockEvent
+    {
         private final ItemStack stack;
 
-        public Place(@Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull ItemStack stack) {
-            super(turtle, TurtleAction.PLACE, player, world, pos);
+        public Place( @Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull ItemStack stack )
+        {
+            super( turtle, TurtleAction.PLACE, player, world, pos );
 
-            Objects.requireNonNull(stack, "stack cannot be null");
+            Objects.requireNonNull( stack, "stack cannot be null" );
             this.stack = stack;
         }
 
@@ -148,8 +169,9 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
          * @return The item stack to be placed.
          */
         @Nonnull
-        public ItemStack getStack() {
-            return this.stack;
+        public ItemStack getStack()
+        {
+            return stack;
         }
     }
 
@@ -160,16 +182,17 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
      *
      * @see TurtleAction#INSPECT
      */
-    public static class Inspect extends TurtleBlockEvent {
-        private final BlockState state;
+    public static class Inspect extends TurtleBlockEvent
+    {
+        private final IBlockState state;
         private final Map<String, Object> data;
 
-        public Inspect(@Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull BlockState state,
-                       @Nonnull Map<String, Object> data) {
-            super(turtle, TurtleAction.INSPECT, player, world, pos);
+        public Inspect( @Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nonnull IBlockState state, @Nonnull Map<String, Object> data )
+        {
+            super( turtle, TurtleAction.INSPECT, player, world, pos );
 
-            Objects.requireNonNull(state, "state cannot be null");
-            Objects.requireNonNull(data, "data cannot be null");
+            Objects.requireNonNull( state, "state cannot be null" );
+            Objects.requireNonNull( data, "data cannot be null" );
             this.data = data;
             this.state = state;
         }
@@ -180,8 +203,9 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
          * @return The inspected block state.
          */
         @Nonnull
-        public BlockState getState() {
-            return this.state;
+        public IBlockState getState()
+        {
+            return state;
         }
 
         /**
@@ -190,18 +214,21 @@ public abstract class TurtleBlockEvent extends TurtlePlayerEvent {
          * @return This block's inspection data.
          */
         @Nonnull
-        public Map<String, Object> getData() {
-            return this.data;
+        public Map<String, Object> getData()
+        {
+            return data;
         }
 
         /**
          * Add new information to the inspection result. Note this will override fields with the same name.
          *
-         * @param newData The data to add. Note all values should be convertible to Lua (see {@link MethodResult#of(Object)}).
+         * @param newData The data to add. Note all values should be convertible to Lua (see
+         *                {@link dan200.computercraft.api.peripheral.IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])}).
          */
-        public void addData(@Nonnull Map<String, ?> newData) {
-            Objects.requireNonNull(newData, "newData cannot be null");
-            this.data.putAll(newData);
+        public void addData( @Nonnull Map<String, ?> newData )
+        {
+            Objects.requireNonNull( newData, "newData cannot be null" );
+            data.putAll( newData );
         }
     }
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtleEvent.java

@@ -3,47 +3,40 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Objects;
+import dan200.computercraft.api.turtle.ITurtleAccess;
+import net.minecraftforge.fml.common.eventhandler.Event;
 
 import javax.annotation.Nonnull;
-
-import com.google.common.eventbus.EventBus;
-import dan200.computercraft.api.turtle.ITurtleAccess;
+import java.util.Objects;
 
 /**
- * A base class for all events concerning a turtle. This will only ever constructed and fired on the server side, so sever specific methods on {@link
- * ITurtleAccess} are safe to use.
+ * A base class for all events concerning a turtle. This will only ever constructed and fired on the server side,
+ * so sever specific methods on {@link ITurtleAccess} are safe to use.
  *
  * You should generally not need to subscribe to this event, preferring one of the more specific classes.
  *
  * @see TurtleActionEvent
  */
-public abstract class TurtleEvent {
-    public static final EventBus EVENT_BUS = new EventBus();
-
+public abstract class TurtleEvent extends Event
+{
     private final ITurtleAccess turtle;
 
-    protected TurtleEvent(@Nonnull ITurtleAccess turtle) {
-        Objects.requireNonNull(turtle, "turtle cannot be null");
+    protected TurtleEvent( @Nonnull ITurtleAccess turtle )
+    {
+        Objects.requireNonNull( turtle, "turtle cannot be null" );
         this.turtle = turtle;
     }
 
-    public static boolean post(TurtleActionEvent event) {
-        EVENT_BUS.post(event);
-        return event.isCancelled();
-    }
-
     /**
      * Get the turtle which is performing this action.
      *
      * @return The access for this turtle.
      */
     @Nonnull
-    public ITurtleAccess getTurtle() {
-        return this.turtle;
+    public ITurtleAccess getTurtle()
+    {
+        return turtle;
     }
-
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtleInspectItemEvent.java

@@ -3,45 +3,38 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Map;
-import java.util.Objects;
+import dan200.computercraft.api.lua.ILuaContext;
+import dan200.computercraft.api.peripheral.IComputerAccess;
+import dan200.computercraft.api.turtle.ITurtleAccess;
+import net.minecraft.item.ItemStack;
 
 import javax.annotation.Nonnull;
-
-import dan200.computercraft.api.lua.MethodResult;
-import dan200.computercraft.api.turtle.ITurtleAccess;
-
-import net.minecraft.item.ItemStack;
+import java.util.Map;
+import java.util.Objects;
 
 /**
  * Fired when a turtle gathers data on an item in its inventory.
  *
- * You may prevent items being inspected, or add additional information to the result. Be aware that this may be fired on the computer thread, and so any
- * operations on it must be thread safe.
+ * You may prevent items being inspected, or add additional information to the result. Be aware that this is fired on
+ * the computer thread, and so any operations on it must be thread safe.
  *
  * @see TurtleAction#INSPECT_ITEM
  */
-public class TurtleInspectItemEvent extends TurtleActionEvent {
+public class TurtleInspectItemEvent extends TurtleActionEvent
+{
     private final ItemStack stack;
     private final Map<String, Object> data;
-    private final boolean mainThread;
 
-    @Deprecated
-    public TurtleInspectItemEvent(@Nonnull ITurtleAccess turtle, @Nonnull ItemStack stack, @Nonnull Map<String, Object> data) {
-        this(turtle, stack, data, false);
-    }
+    public TurtleInspectItemEvent( @Nonnull ITurtleAccess turtle, @Nonnull ItemStack stack, @Nonnull Map<String, Object> data )
+    {
+        super( turtle, TurtleAction.INSPECT_ITEM );
 
-    public TurtleInspectItemEvent(@Nonnull ITurtleAccess turtle, @Nonnull ItemStack stack, @Nonnull Map<String, Object> data, boolean mainThread) {
-        super(turtle, TurtleAction.INSPECT_ITEM);
-
-        Objects.requireNonNull(stack, "stack cannot be null");
-        Objects.requireNonNull(data, "data cannot be null");
+        Objects.requireNonNull( stack, "stack cannot be null" );
+        Objects.requireNonNull( data, "data cannot be null" );
         this.stack = stack;
         this.data = data;
-        this.mainThread = mainThread;
     }
 
     /**
@@ -50,8 +43,9 @@ public class TurtleInspectItemEvent extends TurtleActionEvent {
      * @return The item stack which is being inspected. This should <b>not</b> be modified.
      */
     @Nonnull
-    public ItemStack getStack() {
-        return this.stack;
+    public ItemStack getStack()
+    {
+        return stack;
     }
 
     /**
@@ -60,26 +54,20 @@ public class TurtleInspectItemEvent extends TurtleActionEvent {
      * @return This items's inspection data.
      */
     @Nonnull
-    public Map<String, Object> getData() {
-        return this.data;
-    }
-
-    /**
-     * If this event is being fired on the server thread. When true, information which relies on server state may be exposed.
-     *
-     * @return If this is run on the main thread.
-     */
-    public boolean onMainThread() {
-        return this.mainThread;
+    public Map<String, Object> getData()
+    {
+        return data;
     }
 
     /**
      * Add new information to the inspection result. Note this will override fields with the same name.
      *
-     * @param newData The data to add. Note all values should be convertible to Lua (see {@link MethodResult#of(Object)}).
+     * @param newData The data to add. Note all values should be convertible to Lua (see
+     *                {@link dan200.computercraft.api.peripheral.IPeripheral#callMethod(IComputerAccess, ILuaContext, int, Object[])}).
      */
-    public void addData(@Nonnull Map<String, ?> newData) {
-        Objects.requireNonNull(newData, "newData cannot be null");
-        this.data.putAll(newData);
+    public void addData( @Nonnull Map<String, ?> newData )
+    {
+        Objects.requireNonNull( newData, "newData cannot be null" );
+        data.putAll( newData );
     }
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtleInventoryEvent.java

@@ -3,31 +3,29 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Objects;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-import dan200.computercraft.api.turtle.FakePlayer;
 import dan200.computercraft.api.turtle.ITurtleAccess;
-
-import net.minecraft.inventory.Inventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.FakePlayer;
+import net.minecraftforge.items.IItemHandler;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Objects;
 
 /**
  * Fired when a turtle attempts to interact with an inventory.
  */
-public abstract class TurtleInventoryEvent extends TurtleBlockEvent {
-    private final Inventory handler;
+public abstract class TurtleInventoryEvent extends TurtleBlockEvent
+{
+    private final IItemHandler handler;
 
-    protected TurtleInventoryEvent(@Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action, @Nonnull FakePlayer player, @Nonnull World world,
-                                   @Nonnull BlockPos pos, @Nullable Inventory handler) {
-        super(turtle, action, player, world, pos);
+    protected TurtleInventoryEvent( @Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nullable IItemHandler handler )
+    {
+        super( turtle, action, player, world, pos );
         this.handler = handler;
     }
 
@@ -37,8 +35,9 @@ public abstract class TurtleInventoryEvent extends TurtleBlockEvent {
      * @return The inventory being interacted with, {@code null} if the item will be dropped to/sucked from the world.
      */
     @Nullable
-    public Inventory getItemHandler() {
-        return this.handler;
+    public IItemHandler getItemHandler()
+    {
+        return handler;
     }
 
     /**
@@ -46,9 +45,11 @@ public abstract class TurtleInventoryEvent extends TurtleBlockEvent {
      *
      * @see TurtleAction#SUCK
      */
-    public static class Suck extends TurtleInventoryEvent {
-        public Suck(@Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nullable Inventory handler) {
-            super(turtle, TurtleAction.SUCK, player, world, pos, handler);
+    public static class Suck extends TurtleInventoryEvent
+    {
+        public Suck( @Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nullable IItemHandler handler )
+        {
+            super( turtle, TurtleAction.SUCK, player, world, pos, handler );
         }
     }
 
@@ -57,14 +58,15 @@ public abstract class TurtleInventoryEvent extends TurtleBlockEvent {
      *
      * @see TurtleAction#DROP
      */
-    public static class Drop extends TurtleInventoryEvent {
+    public static class Drop extends TurtleInventoryEvent
+    {
         private final ItemStack stack;
 
-        public Drop(@Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nullable Inventory handler,
-                    @Nonnull ItemStack stack) {
-            super(turtle, TurtleAction.DROP, player, world, pos, handler);
+        public Drop( @Nonnull ITurtleAccess turtle, @Nonnull FakePlayer player, @Nonnull World world, @Nonnull BlockPos pos, @Nullable IItemHandler handler, @Nonnull ItemStack stack )
+        {
+            super( turtle, TurtleAction.DROP, player, world, pos, handler );
 
-            Objects.requireNonNull(stack, "stack cannot be null");
+            Objects.requireNonNull( stack, "stack cannot be null" );
             this.stack = stack;
         }
 
@@ -74,8 +76,9 @@ public abstract class TurtleInventoryEvent extends TurtleBlockEvent {
          * @return The item stack which will be dropped. This should <b>not</b> be modified.
          */
         @Nonnull
-        public ItemStack getStack() {
-            return this.stack;
+        public ItemStack getStack()
+        {
+            return stack;
         }
     }
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtlePlayerEvent.java

@@ -3,28 +3,28 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Objects;
+import dan200.computercraft.api.turtle.ITurtleAccess;
+import net.minecraftforge.common.util.FakePlayer;
 
 import javax.annotation.Nonnull;
-
-import dan200.computercraft.api.turtle.FakePlayer;
-import dan200.computercraft.api.turtle.ITurtleAccess;
+import java.util.Objects;
 
 /**
  * An action done by a turtle which is normally done by a player.
  *
  * {@link #getPlayer()} may be used to modify the player's attributes or perform permission checks.
  */
-public abstract class TurtlePlayerEvent extends TurtleActionEvent {
+public abstract class TurtlePlayerEvent extends TurtleActionEvent
+{
     private final FakePlayer player;
 
-    protected TurtlePlayerEvent(@Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action, @Nonnull FakePlayer player) {
-        super(turtle, action);
+    protected TurtlePlayerEvent( @Nonnull ITurtleAccess turtle, @Nonnull TurtleAction action, @Nonnull FakePlayer player )
+    {
+        super( turtle, action );
 
-        Objects.requireNonNull(player, "player cannot be null");
+        Objects.requireNonNull( player, "player cannot be null" );
         this.player = player;
     }
 
@@ -36,7 +36,8 @@ public abstract class TurtlePlayerEvent extends TurtleActionEvent {
      * @return A {@link FakePlayer} representing this turtle.
      */
     @Nonnull
-    public FakePlayer getPlayer() {
-        return this.player;
+    public FakePlayer getPlayer()
+    {
+        return player;
     }
 }

src/main/java/dan200/computercraft/api/turtle/event/TurtleRefuelEvent.java

@@ -3,32 +3,31 @@
  * Copyright Daniel Ratcliffe, 2011-2020. 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.turtle.event;
 
-import java.util.Objects;
+import dan200.computercraft.api.turtle.ITurtleAccess;
+import net.minecraft.item.ItemStack;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-
-import dan200.computercraft.api.turtle.ITurtleAccess;
-
-import net.minecraft.item.ItemStack;
+import java.util.Objects;
 
 /**
  * Fired when a turtle attempts to refuel from an item.
  *
- * One may use {@link #setCanceled(boolean, String)} to prevent refueling from this specific item. Additionally, you may use {@link #setHandler(Handler)} to
- * register a custom fuel provider.
+ * One may use {@link #setCanceled(boolean, String)} to prevent refueling from this specific item. Additionally, you
+ * may use {@link #setHandler(Handler)} to register a custom fuel provider.
  */
-public class TurtleRefuelEvent extends TurtleActionEvent {
+public class TurtleRefuelEvent extends TurtleActionEvent
+{
     private final ItemStack stack;
     private Handler handler;
 
-    public TurtleRefuelEvent(@Nonnull ITurtleAccess turtle, @Nonnull ItemStack stack) {
-        super(turtle, TurtleAction.REFUEL);
+    public TurtleRefuelEvent( @Nonnull ITurtleAccess turtle, @Nonnull ItemStack stack )
+    {
+        super( turtle, TurtleAction.REFUEL );
 
-        Objects.requireNonNull(turtle, "turtle cannot be null");
+        Objects.requireNonNull( turtle, "turtle cannot be null" );
         this.stack = stack;
     }
 
@@ -39,8 +38,9 @@ public class TurtleRefuelEvent extends TurtleActionEvent {
      *
      * @return The stack to refuel from.
      */
-    public ItemStack getStack() {
-        return this.stack;
+    public ItemStack getStack()
+    {
+        return stack;
     }
 
     /**
@@ -50,19 +50,22 @@ public class TurtleRefuelEvent extends TurtleActionEvent {
      * @see #setHandler(Handler)
      */
     @Nullable
-    public Handler getHandler() {
-        return this.handler;
+    public Handler getHandler()
+    {
+        return handler;
     }
 
     /**
      * Set the refuel handler for this stack.
      *
-     * You should call this if you can actually refuel from this item, and ideally only if there are no existing handlers.
+     * You should call this if you can actually refuel from this item, and ideally only if there are no existing
+     * handlers.
      *
      * @param handler The new refuel handler.
      * @see #getHandler()
      */
-    public void setHandler(@Nullable Handler handler) {
+    public void setHandler( @Nullable Handler handler )
+    {
         this.handler = handler;
     }
 
@@ -70,16 +73,18 @@ public class TurtleRefuelEvent extends TurtleActionEvent {
      * Handles refuelling a turtle from a specific item.
      */
     @FunctionalInterface
-    public interface Handler {
+    public interface Handler
+    {
         /**
          * Refuel a turtle using an item.
          *
          * @param turtle The turtle to refuel.
-         * @param stack The stack to refuel with.
-         * @param slot The slot the stack resides within. This may be used to modify the inventory afterwards.
-         * @param limit The maximum number of refuel operations to perform. This will often correspond to the number of items to consume.
+         * @param stack  The stack to refuel with.
+         * @param slot   The slot the stack resides within. This may be used to modify the inventory afterwards.
+         * @param limit  The maximum number of refuel operations to perform. This will often correspond to the number of
+         *               items to consume.
          * @return The amount of fuel gained.
          */
-        int refuel(@Nonnull ITurtleAccess turtle, @Nonnull ItemStack stack, int slot, int limit);
+        int refuel( @Nonnull ITurtleAccess turtle, @Nonnull ItemStack stack, int slot, int limit );
     }
 }

src/main/java/dan200/computercraft/api/turtle/event/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Turtle|Event", apiVersion = "${version}" )
+package dan200.computercraft.api.turtle.event;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/api/turtle/package-info.java

@@ -0,0 +1,9 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2020. 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.
+ */
+@API( owner = "ComputerCraft", provides = "ComputerCraft|API|Turtle", apiVersion = "${version}" )
+package dan200.computercraft.api.turtle;
+
+import net.minecraftforge.fml.common.API;

src/main/java/dan200/computercraft/client/ClientRegistry.java

@@ -3,121 +3,182 @@
  * Copyright Daniel Ratcliffe, 2011-2020. Do not distribute without permission.
  * Send enquiries to dratcliffe@gmail.com
  */
-
 package dan200.computercraft.client;
 
-import java.util.HashSet;
-import java.util.function.Consumer;
-
 import dan200.computercraft.ComputerCraft;
-import dan200.computercraft.shared.ComputerCraftRegistry;
-import dan200.computercraft.shared.common.IColouredItem;
-import dan200.computercraft.shared.media.items.ItemDisk;
-import dan200.computercraft.shared.media.items.ItemTreasureDisk;
+import dan200.computercraft.client.render.TurtleModelLoader;
+import dan200.computercraft.shared.media.items.ItemDiskLegacy;
 import dan200.computercraft.shared.pocket.items.ItemPocketComputer;
+import dan200.computercraft.shared.turtle.items.ItemTurtleBase;
 import dan200.computercraft.shared.util.Colour;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.ItemMeshDefinition;
+import net.minecraft.client.renderer.block.model.IBakedModel;
+import net.minecraft.client.renderer.block.model.ModelBakery;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.event.ColorHandlerEvent;
+import net.minecraftforge.client.event.ModelBakeEvent;
+import net.minecraftforge.client.event.ModelRegistryEvent;
+import net.minecraftforge.client.event.TextureStitchEvent;
+import net.minecraftforge.client.model.IModel;
+import net.minecraftforge.client.model.ModelLoader;
+import net.minecraftforge.client.model.ModelLoaderRegistry;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
 
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.render.model.ModelLoader;
-import net.minecraft.client.render.model.ModelRotation;
-import net.minecraft.client.render.model.UnbakedModel;
-import net.minecraft.client.texture.SpriteAtlasTexture;
-import net.minecraft.client.util.ModelIdentifier;
-import net.minecraft.resource.ResourceManager;
-import net.minecraft.util.Identifier;
-
-import net.fabricmc.fabric.api.client.rendering.v1.ColorProviderRegistry;
-import net.fabricmc.fabric.api.event.client.ClientSpriteRegistryCallback;
+import javax.annotation.Nonnull;
 
 /**
  * Registers textures and models for items.
  */
-@SuppressWarnings ({
-    "MethodCallSideOnly",
-    "LocalVariableDeclarationSideOnly"
-})
-public final class ClientRegistry {
+@Mod.EventBusSubscriber( modid = ComputerCraft.MOD_ID, value = Side.CLIENT )
+public final class ClientRegistry
+{
     private static final String[] EXTRA_MODELS = new String[] {
-        "turtle_modem_normal_off_left",
-        "turtle_modem_normal_on_left",
-        "turtle_modem_normal_off_right",
-        "turtle_modem_normal_on_right",
-
-        "turtle_modem_advanced_off_left",
-        "turtle_modem_advanced_on_left",
-        "turtle_modem_advanced_off_right",
-        "turtle_modem_advanced_on_right",
+        "turtle_modem_off_left",
+        "turtle_modem_on_left",
+        "turtle_modem_off_right",
+        "turtle_modem_on_right",
         "turtle_crafting_table_left",
         "turtle_crafting_table_right",
-
+        "advanced_turtle_modem_off_left",
+        "advanced_turtle_modem_on_left",
+        "advanced_turtle_modem_off_right",
+        "advanced_turtle_modem_on_right",
         "turtle_speaker_upgrade_left",
         "turtle_speaker_upgrade_right",
 
-        "turtle_colour",
+        "turtle_white",
         "turtle_elf_overlay",
-        };
-
-    private static final String[] EXTRA_TEXTURES = new String[] {
-        // TODO: Gather these automatically from the model. Sadly the model loader isn't available
-        //  when stitching textures.
-        "block/turtle_colour",
-        "block/turtle_elf_overlay",
-        "block/turtle_crafty_face",
-        "block/turtle_speaker_face",
-        };
+    };
 
     private ClientRegistry() {}
 
-    public static void onTextureStitchEvent(SpriteAtlasTexture atlasTexture, ClientSpriteRegistryCallback.Registry registry) {
-        for (String extra : EXTRA_TEXTURES) {
-            registry.register(new Identifier(ComputerCraft.MOD_ID, extra));
+    @SubscribeEvent
+    public static void registerModels( ModelRegistryEvent event )
+    {
+        ModelLoaderRegistry.registerLoader( TurtleModelLoader.INSTANCE );
+
+        // Register item models
+        registerUniversalItemModel( ComputerCraft.Items.computer, "computer" );
+        registerItemModel( ComputerCraft.Items.commandComputer, 0, "command_computer" );
+
+        registerItemModel( ComputerCraft.Items.pocketComputer, 0, "pocket_computer" );
+        registerItemModel( ComputerCraft.Items.pocketComputer, 1, "advanced_pocket_computer" );
+
+        registerItemModel( ComputerCraft.Items.peripheral, 0, "peripheral" );
+        registerItemModel( ComputerCraft.Items.peripheral, 1, "wireless_modem" );
+        registerItemModel( ComputerCraft.Items.peripheral, 2, "monitor" );
+        registerItemModel( ComputerCraft.Items.peripheral, 3, "printer" );
+        registerItemModel( ComputerCraft.Items.peripheral, 4, "advanced_monitor" );
+        registerItemModel( ComputerCraft.Items.cable, 0, "cable" );
+        registerItemModel( ComputerCraft.Items.cable, 1, "wired_modem" );
+        registerItemModel( ComputerCraft.Items.advancedModem, 0, "advanced_modem" );
+        registerItemModel( ComputerCraft.Items.peripheral, 5, "speaker" );
+        registerItemModel( ComputerCraft.Items.wiredModemFull, 0, "wired_modem_full" );
+
+        registerUniversalItemModel( ComputerCraft.Items.disk, "disk" );
+        registerItemModel( ComputerCraft.Items.diskExpanded, 0, "disk_expanded" );
+        registerItemModel( ComputerCraft.Items.treasureDisk, 0, "treasure_disk" );
+
+        registerItemModel( ComputerCraft.Items.printout, 0, "printout" );
+        registerItemModel( ComputerCraft.Items.printout, 1, "pages" );
+        registerItemModel( ComputerCraft.Items.printout, 2, "book" );
+
+        registerUniversalItemModel( ComputerCraft.Items.turtle, "turtle" );
+        registerUniversalItemModel( ComputerCraft.Items.turtleExpanded, "turtle" );
+        registerUniversalItemModel( ComputerCraft.Items.turtleAdvanced, "turtle_advanced" );
+    }
+
+    @SubscribeEvent
+    public static void onTextureStitchEvent( TextureStitchEvent.Pre event )
+    {
+        // Load all textures for the extra models
+        TextureMap map = event.getMap();
+        for( String upgrade : EXTRA_MODELS )
+        {
+            IModel model = ModelLoaderRegistry.getModelOrMissing( new ResourceLocation( "computercraft", "block/" + upgrade ) );
+            for( ResourceLocation texture : model.getTextures() ) map.registerSprite( texture );
         }
     }
 
-    @SuppressWarnings ("NewExpressionSideOnly")
-    public static void onModelBakeEvent(ResourceManager manager, Consumer<ModelIdentifier> out) {
-        for (String model : EXTRA_MODELS) {
-            out.accept(new ModelIdentifier(new Identifier(ComputerCraft.MOD_ID, model), "inventory"));
-        }
+    @SubscribeEvent
+    public static void onModelBakeEvent( ModelBakeEvent event )
+    {
+        // Load all extra models
+        for( String model : EXTRA_MODELS ) loadBlockModel( event, model );
     }
 
-    public static void onItemColours() {
-        ColorProviderRegistry.ITEM.register((stack, layer) -> {
-            return layer == 1 ? ((ItemDisk) stack.getItem()).getColour(stack) : 0xFFFFFF;
-        }, ComputerCraftRegistry.ModItems.DISK);
+    @SubscribeEvent
+    public static void onItemColours( ColorHandlerEvent.Item event )
+    {
+        event.getItemColors().registerItemColorHandler(
+            ( stack, layer ) -> layer == 1 ? ((ItemDiskLegacy) stack.getItem()).getColour( stack ) : 0xFFFFFF,
+            ComputerCraft.Items.disk, ComputerCraft.Items.diskExpanded
+        );
 
-        ColorProviderRegistry.ITEM.register((stack, layer) -> layer == 1 ? ItemTreasureDisk.getColour(stack) : 0xFFFFFF,
-                                            ComputerCraftRegistry.ModItems.TREASURE_DISK);
-
-        ColorProviderRegistry.ITEM.register((stack, layer) -> {
-            switch (layer) {
-            case 0:
-            default:
-                return 0xFFFFFF;
-            case 1: // Frame colour
-                return IColouredItem.getColourBasic(stack);
-            case 2: // Light colour
+        event.getItemColors().registerItemColorHandler( ( stack, layer ) -> {
+            switch( layer )
             {
-                int light = ItemPocketComputer.getLightState(stack);
-                return light == -1 ? Colour.BLACK.getHex() : light;
+                case 0:
+                default:
+                    return 0xFFFFFF;
+                case 1: // Frame colour
+                    return ComputerCraft.Items.pocketComputer.getColour( stack );
+                case 2: // Light colour
+                {
+                    int light = ItemPocketComputer.getLightState( stack );
+                    return light == -1 ? Colour.Black.getHex() : light;
+                }
             }
-            }
-        }, ComputerCraftRegistry.ModItems.POCKET_COMPUTER_NORMAL, ComputerCraftRegistry.ModItems.POCKET_COMPUTER_ADVANCED);
+        }, ComputerCraft.Items.pocketComputer );
 
         // Setup turtle colours
-        ColorProviderRegistry.ITEM.register((stack, tintIndex) -> tintIndex == 0 ? ((IColouredItem) stack.getItem()).getColour(stack) : 0xFFFFFF,
-                                            ComputerCraftRegistry.ModBlocks.TURTLE_NORMAL,
-                                            ComputerCraftRegistry.ModBlocks.TURTLE_ADVANCED);
+        event.getItemColors().registerItemColorHandler(
+            ( stack, tintIndex ) -> tintIndex == 0 ? ((ItemTurtleBase) stack.getItem()).getColour( stack ) : 0xFFFFFF,
+            ComputerCraft.Blocks.turtle, ComputerCraft.Blocks.turtleExpanded, ComputerCraft.Blocks.turtleAdvanced
+        );
     }
 
-    private static BakedModel bake(ModelLoader loader, UnbakedModel model, Identifier identifier) {
-        model.getTextureDependencies(loader::getOrLoadModel, new HashSet<>());
-        return model.bake(loader,
-                          spriteIdentifier -> MinecraftClient.getInstance()
-                                                             .getSpriteAtlas(spriteIdentifier.getAtlasId())
-                                                             .apply(spriteIdentifier.getTextureId()),
-                          ModelRotation.X0_Y0,
-                          identifier);
+    private static void registerItemModel( Item item, int damage, String name )
+    {
+        ResourceLocation location = new ResourceLocation( ComputerCraft.MOD_ID, name );
+        final ModelResourceLocation res = new ModelResourceLocation( location, "inventory" );
+        ModelBakery.registerItemVariants( item, location );
+        ModelLoader.setCustomModelResourceLocation( item, damage, res );
+    }
+
+    private static void registerUniversalItemModel( Item item, String mainModel )
+    {
+        ResourceLocation mainLocation = new ResourceLocation( ComputerCraft.MOD_ID, mainModel );
+        ModelBakery.registerItemVariants( item, mainLocation );
+
+        final ModelResourceLocation mainModelLocation = new ModelResourceLocation( mainLocation, "inventory" );
+        ModelLoader.setCustomMeshDefinition( item, new ItemMeshDefinition()
+        {
+            @Nonnull
+            @Override
+            public ModelResourceLocation getModelLocation( @Nonnull ItemStack stack )
+            {
+                return mainModelLocation;
+            }
+        } );
+    }
+
+    private static void loadBlockModel( ModelBakeEvent event, String name )
+    {
+        IModel model = ModelLoaderRegistry.getModelOrMissing( new ResourceLocation( ComputerCraft.MOD_ID, "block/" + name ) );
+        IBakedModel bakedModel = model.bake(
+            model.getDefaultState(), DefaultVertexFormats.ITEM,
+            location -> Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite( location.toString() )
+        );
+
+        event.getModelRegistry().putObject( new ModelResourceLocation( ComputerCraft.MOD_ID + ":" + name, "inventory" ), bakedModel );
     }
 }

src/main/java/dan200/computercraft/client/ClientTableFormatter.java

@@ -3,89 +3,86 @@
  * Copyright Daniel Ratcliffe, 2011-2020. Do not distribute without permission.
  * Send enquiries to dratcliffe@gmail.com
  */
-
 package dan200.computercraft.client;
 
-import javax.annotation.Nullable;
-
-import dan200.computercraft.mixin.ChatHudAccess;
 import dan200.computercraft.shared.command.text.ChatHelpers;
 import dan200.computercraft.shared.command.text.TableBuilder;
 import dan200.computercraft.shared.command.text.TableFormatter;
 import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiNewChat;
+import net.minecraft.client.gui.GuiUtilRenderComponents;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextFormatting;
 import org.apache.commons.lang3.StringUtils;
 
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.font.TextRenderer;
-import net.minecraft.client.gui.hud.ChatHud;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-import net.minecraft.util.math.MathHelper;
+import javax.annotation.Nullable;
+import java.util.List;
 
-@SuppressWarnings ({
-    "MethodCallSideOnly",
-    "LocalVariableDeclarationSideOnly"
-})
-public class ClientTableFormatter implements TableFormatter {
+public class ClientTableFormatter implements TableFormatter
+{
     public static final ClientTableFormatter INSTANCE = new ClientTableFormatter();
 
     private static Int2IntOpenHashMap lastHeights = new Int2IntOpenHashMap();
 
+    private static FontRenderer renderer()
+    {
+        return Minecraft.getMinecraft().fontRenderer;
+    }
+
     @Override
     @Nullable
-    public Text getPadding(Text component, int width) {
-        int extraWidth = width - this.getWidth(component);
-        if (extraWidth <= 0) {
-            return null;
-        }
+    public ITextComponent getPadding( ITextComponent component, int width )
+    {
+        int extraWidth = width - getWidth( component );
+        if( extraWidth <= 0 ) return null;
 
-        TextRenderer renderer = renderer();
+        FontRenderer renderer = renderer();
 
-        float spaceWidth = renderer.getWidth(" ");
-        int spaces = MathHelper.floor(extraWidth / spaceWidth);
+        float spaceWidth = renderer.getCharWidth( ' ' );
+        int spaces = MathHelper.floor( extraWidth / spaceWidth );
         int extra = extraWidth - (int) (spaces * spaceWidth);
 
-        return ChatHelpers.coloured(StringUtils.repeat(' ', spaces) + StringUtils.repeat((char) 712, extra), Formatting.GRAY);
-    }
-
-    private static TextRenderer renderer() {
-        return MinecraftClient.getInstance().textRenderer;
+        return ChatHelpers.coloured( StringUtils.repeat( ' ', spaces ) + StringUtils.repeat( (char) 712, extra ), TextFormatting.GRAY );
     }
 
     @Override
-    public int getColumnPadding() {
+    public int getColumnPadding()
+    {
         return 3;
     }
 
     @Override
-    public int getWidth(Text component) {
-        return renderer().getWidth(component);
+    public int getWidth( ITextComponent component )
+    {
+        return renderer().getStringWidth( component.getFormattedText() );
     }
 
     @Override
-    public void writeLine(int id, Text component) {
-        MinecraftClient mc = MinecraftClient.getInstance();
-        ChatHud chat = mc.inGameHud.getChatHud();
+    public void writeLine( int id, ITextComponent component )
+    {
+        Minecraft mc = Minecraft.getMinecraft();
+        GuiNewChat chat = mc.ingameGUI.getChatGUI();
 
-        // TODO: Trim the text if it goes over the allowed length
-        // int maxWidth = MathHelper.floor( chat.getChatWidth() / chat.getScale() );
-        // List<ITextProperties> list = RenderComponentsUtil.func_238505_a_( component, maxWidth, mc.fontRenderer );
-        // if( !list.isEmpty() ) chat.printChatMessageWithOptionalDeletion( list.get( 0 ), id );
-        ((ChatHudAccess)chat).callAddMessage(component, id);
+        // Trim the text if it goes over the allowed length
+        int maxWidth = MathHelper.floor( chat.getChatWidth() / chat.getChatScale() );
+        List<ITextComponent> list = GuiUtilRenderComponents.splitText( component, maxWidth, mc.fontRenderer, false, false );
+        if( !list.isEmpty() ) chat.printChatMessageWithOptionalDeletion( list.get( 0 ), id );
     }
 
     @Override
-    public int display(TableBuilder table) {
-        ChatHud chat = MinecraftClient.getInstance().inGameHud.getChatHud();
+    public int display( TableBuilder table )
+    {
+        GuiNewChat chat = Minecraft.getMinecraft().ingameGUI.getChatGUI();
 
-        int lastHeight = lastHeights.get(table.getId());
+        int lastHeight = lastHeights.get( table.getId() );
 
-        int height = TableFormatter.super.display(table);
-        lastHeights.put(table.getId(), height);
+        int height = TableFormatter.super.display( table );
+        lastHeights.put( table.getId(), height );
 
-        for (int i = height; i < lastHeight; i++) {
-            ((ChatHudAccess)chat).callRemoveMessage(i + table.getId());
-        }
+        for( int i = height; i < lastHeight; i++ ) chat.deleteChatLine( i + table.getId() );
         return height;
     }
 }