.editorconfig

@@ -1,7 +1,3 @@
-# SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: CC0-1.0
-
 root = true
 
 [*]
@@ -12,17 +8,6 @@ charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
 
-ij_continuation_indent_size = 4
-ij_any_do_while_brace_force = if_multiline
-ij_any_if_brace_force = if_multiline
-ij_any_for_brace_force = if_multiline
-ij_any_spaces_within_array_initializer_braces = true
-
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true
-ij_kotlin_method_parameters_wrap = off
-ij_kotlin_call_parameters_wrap = off
-
 [*.md]
 trim_trailing_whitespace = false
 

.git-blame-ignore-revs

@@ -1,6 +0,0 @@
-# SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: CC0-1.0
-
-# Reformat everything
-f478c4ffc4fb9fc2200ec9b0bc751d047057ce81

.gitattributes

@@ -1,21 +1,15 @@
-# SPDX-FileCopyrightText: 2020 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: CC0-1.0
-
 # Ignore changes in generated files
-projects/*/src/generated/** linguist-generated
+src/generated/resources/data/** linguist-generated
-projects/common/src/testMod/resources/data/cctest/structures/* linguist-generated
+src/test/server-files/structures linguist-generated
 
 * text=auto
 
 *.gradle eol=lf diff=java
 *.java   eol=lf diff=java
 *.kt     eol=lf diff=java
-*.kts    eol=lf diff=java
 *.lua    eol=lf
 *.md     eol=lf diff=markdown
 *.txt    eol=lf
 
 *.png binary
 *.jar binary
-*.dfpwm binary

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -8,10 +8,8 @@ body:
     label: Minecraft Version
     description: What version of Minecraft are you using?
     options:
+      - 1.15.x
       - 1.16.x
-      - 1.18.x
-      - 1.19.x
-      - 1.20.x
   validations:
     required: true
 - type: input

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-- name: GitHub Discussions
-  url: https://github.com/cc-tweaked/CC-Tweaked/discussions
-  about: Ask questions on GitHub Discussions.

.github/ISSUE_TEMPLATE/something_else.md

@@ -1,4 +0,0 @@
----
-name: Something else
-about: An issue about something else.
----

.github/workflows/main-ci.yml

@@ -8,97 +8,54 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - name: 📥 Clone repository
+    - uses: actions/checkout@v2
-      uses: actions/checkout@v3
 
-    - name: 📥 Set up Java
+    - name: Set up Java 8
-      uses: actions/setup-java@v3
+      uses: actions/setup-java@v1
       with:
-        java-version: 17
+        java-version: 8
-        distribution: 'temurin'
 
-    - name: 📥 Setup Gradle
+    - name: Cache gradle dependencies
-      uses: gradle/gradle-build-action@v2
+      uses: actions/cache@v2
       with:
-        cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
+        path: ~/.gradle/caches
+        key: ${{ runner.os }}-gradle-${{ hashFiles('gradle.properties') }}
+        restore-keys: |
+          ${{ runner.os }}-gradle-
 
     - name: Disable Gradle daemon
       run: |
         mkdir -p ~/.gradle
         echo "org.gradle.daemon=false" >> ~/.gradle/gradle.properties
 
-    - name: ⚒️ Build
+    - name: Build with Gradle
-      run: ./gradlew assemble || ./gradlew assemble
+      run: |
+        ./gradlew assemble || ./gradlew assemble
+        ./gradlew downloadAssets || ./gradlew downloadAssets
+        ./gradlew build
 
-    - name: 💡 Lint
+    - name: Upload Jar
-      uses: pre-commit/action@v3.0.0
+      uses: actions/upload-artifact@v2
+      with:
+        name: CC-Tweaked
+        path: build/libs
 
-    - name: 🧪 Run tests
+    - name: Upload Coverage
-      run: ./gradlew test validateMixinNames checkChangelog
+      uses: codecov/codecov-action@v1
 
-    - name: 📥 Download assets for game tests
+    - name: Parse test reports
-      run: ./gradlew downloadAssets || ./gradlew downloadAssets
-
-    - name: 🧪 Run integration tests
-      run: ./gradlew runGametest
-
-    - name: 🧪 Run client tests
-      run: ./gradlew runGametestClient # Not checkClient, as no point running rendering tests.
-      # These are a little flaky on GH actions: its useful to run them, but don't break the build.
-      continue-on-error: true
-
-    - name: 🧪 Parse test reports
       run: ./tools/parse-reports.py
       if: ${{ failure() }}
 
-    - name: 📦 Prepare Jars
+    - name: Cache pre-commit
+      uses: actions/cache@v2
+      with:
+        path: ~/.cache/pre-commit
+        key: ${{ runner.os }}-pre-commit-${{ hashFiles('config/pre-commit/config.yml') }}
+        restore-keys: |
+          ${{ runner.os }}-pre-commit-
+
+    - name: Run linters
       run: |
-        # Find the main jar and append the git hash onto it.
+        pip install pre-commit
-        mkdir -p jars
+        pre-commit run --config config/pre-commit/config.yml --show-diff-on-failure --all --color=always
-        find projects/forge/build/libs projects/fabric/build/libs -type f -regex '.*[0-9.]+\(-SNAPSHOT\)?\.jar$' -exec bash -c 'cp {} "jars/$(basename {} .jar)-$(git rev-parse HEAD).jar"' \;
-
-    - name: 📤 Upload Jar
-      uses: actions/upload-artifact@v3
-      with:
-        name: CC-Tweaked
-        path: ./jars
-
-    - name: 📤 Upload coverage
-      uses: codecov/codecov-action@v3
-
-  build-core:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-        - name: Windows
-          uses: windows-latest
-
-        - name: macOS
-          uses: macos-latest
-
-    name: Test on ${{ matrix.name }}
-    runs-on: ${{ matrix.uses }}
-
-    steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
-
-    - name: Set up Java
-      uses: actions/setup-java@v3
-      with:
-        java-version: 17
-        distribution: 'temurin'
-
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2
-      with:
-        cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
-
-    - name: Run tests
-      run: |
-        ./gradlew --configure-on-demand :core:test
-
-    - name: Parse test reports
-      run: python3 ./tools/parse-reports.py
-      if: ${{ failure() }}

.github/workflows/make-doc.sh

@@ -12,8 +12,8 @@ chmod 600 "$HOME/.ssh/key"
 
 # And upload
 rsync -avc -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no -p $SSH_PORT" \
-      "$GITHUB_WORKSPACE/projects/web/build/site/" \
+      "$GITHUB_WORKSPACE/build/docs/lua/" \
-      "$SSH_USER@$SSH_HOST:/$DEST"
+      "$SSH_USER@$SSH_HOST:/var/www/tweaked.cc/$DEST"
 rsync -avc -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no -p $SSH_PORT" \
-      "$GITHUB_WORKSPACE/projects/common-api/build/docs/javadoc/" \
+      "$GITHUB_WORKSPACE/build/docs/javadoc/" \
-      "$SSH_USER@$SSH_HOST:/$DEST/javadoc"
+      "$SSH_USER@$SSH_HOST:/var/www/tweaked.cc/$DEST/javadoc"

.github/workflows/make-doc.yml

@@ -3,8 +3,7 @@ name: Build documentation
 on:
   push:
     branches:
-    - mc-1.19.x
+    - mc-1.16.x
-    - mc-1.20.x
 
 jobs:
   make_doc:
@@ -12,25 +11,35 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - name: Clone repository
+    - uses: actions/checkout@v2
-      uses: actions/checkout@v3
 
-    - name: Set up Java
+    - name: Set up Java 8
       uses: actions/setup-java@v1
       with:
-        java-version: 17
+        java-version: 8
-        distribution: 'temurin'
 
-    - name: Setup Gradle
+    - name: Cache gradle dependencies
-      uses: gradle/gradle-build-action@v2
+      uses: actions/cache@v2
       with:
-        cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
+        path: ~/.gradle/caches
+        key: ${{ runner.os }}-gradle-${{ hashFiles('gradle.properties') }}
+        restore-keys: |
+          ${{ runner.os }}-gradle-
+
+    - name: Setup illuaminate
+      run: |
+        test -d bin || mkdir bin
+        test -f bin/illuaminate || wget -q -Obin/illuaminate https://squiddev.cc/illuaminate/linux-x86-64/illuaminate
+        chmod +x bin/illuaminate
+
+    - name: Setup node
+      run: npm ci
 
     - name: Build with Gradle
       run: ./gradlew compileJava --no-daemon || ./gradlew compileJava --no-daemon
 
     - name: Generate documentation
-      run: ./gradlew docWebsite :common-api:javadoc  --no-daemon
+      run: ./gradlew docWebsite javadoc --no-daemon
 
     - name: Upload documentation
       run: .github/workflows/make-doc.sh 2> /dev/null

.gitignore

@@ -1,26 +1,15 @@
-# SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: CC0-1.0
-
 # Build directories
 /classes
 /logs
 /build
-/projects/*/logs
-/projects/fabric/fabricloader.log
-/projects/*/build
-/projects/*/src/test/generated_tests/
-/buildSrc/build
 /out
-/buildSrc/out
-/jars
 /doc/out/
 /node_modules
-.jqwik-database
 
 # Runtime directories
 /run
-/projects/*/run
+/run-*
+/test-files
 
 *.ipr
 *.iws
@@ -33,6 +22,8 @@
 /.project
 /.settings
 /.vscode
+bin/
 *.launch
 
-/projects/*/src/generated/resources/.cache
+/src/generated/resources/.cache
+/src/web/mount/*.d.ts

.gitpod.yml

@@ -1,7 +1,3 @@
-# SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: MPL-2.0
-
 image:
   file: config/gitpod/Dockerfile
 
@@ -21,6 +17,6 @@ vscode:
 
 tasks:
   - name: Setup pre-commit hool
-    init: pre-commit install --allow-missing-config
+    init: pre-commit install --config config/pre-commit/config.yml --allow-missing-config
   - name: Install npm packages
     init: npm ci

.pre-commit-config.yaml

@@ -1,63 +0,0 @@
-# SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: CC0-1.0
-
-# See https://pre-commit.com for more information
-# See https://pre-commit.com/hooks.html for more hooks
-repos:
-- repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.4.0
-  hooks:
-  - id: trailing-whitespace
-  - id: end-of-file-fixer
-  - id: check-merge-conflict
-
-  # Quick syntax checkers
-  - id: check-xml
-  - id: check-yaml
-  - id: check-toml
-  - id: check-json
-    exclude: "tsconfig\\.json$"
-
-- repo: https://github.com/editorconfig-checker/editorconfig-checker.python
-  rev: 2.7.2
-  hooks:
-  - id: editorconfig-checker
-    args: ['-disable-indentation']
-    exclude: "^(.*\\.(bat)|LICENSE)$"
-
-- repo: https://github.com/fsfe/reuse-tool
-  rev: v2.1.0
-  hooks:
-  - id: reuse
-
-- repo: local
-  hooks:
-  - id: license
-    name: Spotless
-    files: ".*\\.(java|kt|kts)$"
-    language: system
-    entry: ./gradlew spotlessApply
-    pass_filenames: false
-    require_serial: true
-  - id: checkstyle
-    name: Check Java codestyle
-    files: ".*\\.java$"
-    language: system
-    entry: ./gradlew checkstyle
-    pass_filenames: false
-    require_serial: true
-  - id: illuaminate
-    name: Check Lua code
-    files: ".*\\.(lua|java|md)"
-    language: system
-    entry: ./gradlew lintLua
-    pass_filenames: false
-    require_serial: true
-
-exclude: |
-  (?x)^(
-    projects/[a-z]+/src/generated|
-    projects/core/src/test/resources/test-rom/data/json-parsing/|
-    .*\.dfpwm
-  )

.reuse/dep5

@@ -1,100 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Source: https://github.com/cc-tweaked/cc-tweaked
-Upstream-Name: CC: Tweaked
-Upstream-Contact: Jonathan Coates <git@squiddev.cc>
-
-Files:
-  projects/common/src/main/resources/assets/computercraft/sounds.json
-  projects/common/src/main/resources/assets/computercraft/sounds/empty.ogg
-  projects/common/src/testMod/resources/data/cctest/computercraft/turtle_upgrades/*
-  projects/common/src/testMod/resources/data/cctest/structures/*
-  projects/fabric/src/generated/*
-  projects/forge/src/generated/*
-  projects/web/src/htmlTransform/export/index.json
-  projects/web/src/htmlTransform/export/items/minecraft/*
-Comment: Generated/data files are CC0.
-Copyright: The CC: Tweaked Developers
-License: CC0-1.0
-
-Files:
-  doc/images/*
-  package.json
-  package-lock.json
-  projects/common/src/client/resources/computercraft-client.mixins.json
-  projects/common/src/main/resources/assets/minecraft/shaders/core/computercraft/monitor_tbo.json
-  projects/common/src/main/resources/computercraft.mixins.json
-  projects/common/src/testMod/resources/computercraft-gametest.mixins.json
-  projects/common/src/testMod/resources/data/computercraft/loot_tables/treasure_disk.json
-  projects/common/src/testMod/resources/pack.mcmeta
-  projects/core/src/main/resources/data/computercraft/lua/rom/modules/command/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/modules/main/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/modules/turtle/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/motd.txt
-  projects/fabric-api/src/main/modJson/fabric.mod.json
-  projects/fabric/src/client/resources/computercraft-client.fabric.mixins.json
-  projects/fabric/src/main/resources/computercraft.fabric.mixins.json
-  projects/fabric/src/main/resources/fabric.mod.json
-  projects/fabric/src/testMod/resources/computercraft-gametest.fabric.mixins.json
-  projects/fabric/src/testMod/resources/fabric.mod.json
-  projects/forge/src/client/resources/computercraft-client.forge.mixins.json
-  projects/web/src/frontend/mount/.settings
-  projects/web/src/frontend/mount/example.nfp
-  projects/web/src/frontend/mount/example.nft
-  projects/web/src/frontend/mount/expr_template.lua
-  projects/web/tsconfig.json
-Comment: Several assets where it's inconvenient to create a .license file.
-Copyright: The CC: Tweaked Developers
-License: MPL-2.0
-
-Files:
-  doc/logo.png
-  doc/logo-darkmode.png
-  projects/common/src/main/resources/assets/computercraft/models/*
-  projects/common/src/main/resources/assets/computercraft/textures/*
-  projects/common/src/main/resources/pack.mcmeta
-  projects/common/src/main/resources/pack.png
-  projects/core/src/main/resources/assets/computercraft/textures/gui/term_font.png
-  projects/core/src/main/resources/data/computercraft/lua/rom/autorun/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/help/*
-  projects/core/src/main/resources/data/computercraft/lua/rom/programs/fun/advanced/levels/*
-  projects/web/src/htmlTransform/export/items/computercraft/*
-Comment: Bulk-license original assets as CCPL.
-Copyright: 2011 Daniel Ratcliffe
-License: LicenseRef-CCPL
-
-Files:
-  projects/common/src/main/resources/assets/computercraft/lang/cs_cz.json
-  projects/common/src/main/resources/assets/computercraft/lang/ko_kr.json
-  projects/common/src/main/resources/assets/computercraft/lang/pl_pl.json
-  projects/common/src/main/resources/assets/computercraft/lang/pt_br.json
-  projects/common/src/main/resources/assets/computercraft/lang/ru_ru.json
-  projects/common/src/main/resources/assets/computercraft/lang/uk_ua.json
-  projects/common/src/main/resources/assets/computercraft/lang/zh_cn.json
-Comment: Community-contributed license files
-Copyright: 2017 The CC: Tweaked Developers
-License: LicenseRef-CCPL
-
-Files:
-  projects/common/src/main/resources/assets/computercraft/lang/*
-Comment: Community-contributed license files
-Copyright: 2017 The CC: Tweaked Developers
-License: MPL-2.0
-
-Files:
-  .github/*
-Comment:
-  GitHub build scripts are CC0. While we could add a header to each file,
-  it's unclear if it will break actions or issue templates in some way.
-Copyright: Jonathan Coates <git@squiddev.cc>
-License: CC0-1.0
-
-Files:
-  gradle/wrapper/*
-  gradlew
-  gradlew.bat
-Copyright: Gradle Inc
-License: Apache-2.0
-
-Files: projects/core/src/test/resources/test-rom/data/json-parsing/*
-Copyright: 2016 Nicolas Seriot
-License: MIT

CODE_OF_CONDUCT.md

@@ -1,138 +0,0 @@
-<!--
-SPDX-FileCopyrightText: 2014 Coraline Ada Ehmke and contributors
-
-SPDX-License-Identifier: CC-BY-4.0
--->
-
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, caste, color, religion, or sexual
-identity and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the overall
-  community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or advances of
-  any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email address,
-  without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-"conduct AT squiddev DOT cc". All complaints will be reviewed and investigated
-promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series of
-actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or permanent
-ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior, harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within the
-community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.1, available at
-[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
-
-Community Impact Guidelines were inspired by
-[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
-
-For answers to common questions about this code of conduct, see the FAQ at
-[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
-[https://www.contributor-covenant.org/translations][translations].
-
-[homepage]: https://www.contributor-covenant.org
-[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
-[Mozilla CoC]: https://github.com/mozilla/diversity
-[FAQ]: https://www.contributor-covenant.org/faq
-[translations]: https://www.contributor-covenant.org/translations

CONTRIBUTING.md

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

LICENSES/Apache-2.0.txt

@@ -1,73 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
-
-"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
-
-"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
-
-"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
-
-"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
-
-"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
-
-"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
-
-"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
-
-"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
-
-"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
-
-     (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
-
-     (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
-
-     (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
-
-     (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
-
-     You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

LICENSES/CC-BY-3.0.txt

@@ -1,93 +0,0 @@
-Creative Commons Attribution 3.0 Unported
-
- CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.
-
-License
-
-THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.
-
-BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.
-
-1. Definitions
-
-     a. "Adaptation" means a work based upon the Work, or upon the Work and other pre-existing works, such as a translation, adaptation, derivative work, arrangement of music or other alterations of a literary or artistic work, or phonogram or performance and includes cinematographic adaptations or any other form in which the Work may be recast, transformed, or adapted including in any form recognizably derived from the original, except that a work that constitutes a Collection will not be considered an Adaptation for the purpose of this License. For the avoidance of doubt, where the Work is a musical work, performance or phonogram, the synchronization of the Work in timed-relation with a moving image ("synching") will be considered an Adaptation for the purpose of this License.
-
-     b. "Collection" means a collection of literary or artistic works, such as encyclopedias and anthologies, or performances, phonograms or broadcasts, or other works or subject matter other than works listed in Section 1(f) below, which, by reason of the selection and arrangement of their contents, constitute intellectual creations, in which the Work is included in its entirety in unmodified form along with one or more other contributions, each constituting separate and independent works in themselves, which together are assembled into a collective whole. A work that constitutes a Collection will not be considered an Adaptation (as defined above) for the purposes of this License.
-
-     c. "Distribute" means to make available to the public the original and copies of the Work or Adaptation, as appropriate, through sale or other transfer of ownership.
-
-     d. "Licensor" means the individual, individuals, entity or entities that offer(s) the Work under the terms of this License.
-
-     e. "Original Author" means, in the case of a literary or artistic work, the individual, individuals, entity or entities who created the Work or if no individual or entity can be identified, the publisher; and in addition (i) in the case of a performance the actors, singers, musicians, dancers, and other persons who act, sing, deliver, declaim, play in, interpret or otherwise perform literary or artistic works or expressions of folklore; (ii) in the case of a phonogram the producer being the person or legal entity who first fixes the sounds of a performance or other sounds; and, (iii) in the case of broadcasts, the organization that transmits the broadcast.
-
-     f. "Work" means the literary and/or artistic work offered under the terms of this License including without limitation any production in the literary, scientific and artistic domain, whatever may be the mode or form of its expression including digital form, such as a book, pamphlet and other writing; a lecture, address, sermon or other work of the same nature; a dramatic or dramatico-musical work; a choreographic work or entertainment in dumb show; a musical composition with or without words; a cinematographic work to which are assimilated works expressed by a process analogous to cinematography; a work of drawing, painting, architecture, sculpture, engraving or lithography; a photographic work to which are assimilated works expressed by a process analogous to photography; a work of applied art; an illustration, map, plan, sketch or three-dimensional work relative to geography, topography, architecture or science; a performance; a broadcast; a phonogram; a compilation of data to the extent it is protected as a copyrightable work; or a work performed by a variety or circus performer to the extent it is not otherwise considered a literary or artistic work.
-
-     g. "You" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.
-
-     h. "Publicly Perform" means to perform public recitations of the Work and to communicate to the public those public recitations, by any means or process, including by wire or wireless means or public digital performances; to make available to the public Works in such a way that members of the public may access these Works from a place and at a place individually chosen by them; to perform the Work to the public by any means or process and the communication to the public of the performances of the Work, including by public digital performance; to broadcast and rebroadcast the Work by any means including signs, sounds or images.
-
-     i. "Reproduce" means to make copies of the Work by any means including without limitation by sound or visual recordings and the right of fixation and reproducing fixations of the Work, including storage of a protected performance or phonogram in digital form or other electronic medium.
-
-2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.
-
-3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:
-
-     a. to Reproduce the Work, to incorporate the Work into one or more Collections, and to Reproduce the Work as incorporated in the Collections;
-
-     b. to create and Reproduce Adaptations provided that any such Adaptation, including any translation in any medium, takes reasonable steps to clearly label, demarcate or otherwise identify that changes were made to the original Work. For example, a translation could be marked "The original work was translated from English to Spanish," or a modification could indicate "The original work has been modified.";
-
-     c. to Distribute and Publicly Perform the Work including as incorporated in Collections; and,
-
-     d. to Distribute and Publicly Perform Adaptations.
-
-     e. For the avoidance of doubt:
-
-          i. Non-waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;
-
-          ii. Waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor waives the exclusive right to collect such royalties for any exercise by You of the rights granted under this License; and,
-
-          iii. Voluntary License Schemes. The Licensor waives the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License.
-
-The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. Subject to Section 8(f), all rights not expressly granted by Licensor are hereby reserved.
-
-4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:
-
-     a. You may Distribute or Publicly Perform the Work only under the terms of this License. You must include a copy of, or the Uniform Resource Identifier (URI) for, this License with every copy of the Work You Distribute or Publicly Perform. You may not offer or impose any terms on the Work that restrict the terms of this License or the ability of the recipient of the Work to exercise the rights granted to that recipient under the terms of the License. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties with every copy of the Work You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Work, You may not impose any effective technological measures on the Work that restrict the ability of a recipient of the Work from You to exercise the rights granted to that recipient under the terms of the License. This Section 4(a) applies to the Work as incorporated in a Collection, but this does not require the Collection apart from the Work itself to be made subject to the terms of this License. If You create a Collection, upon notice from any Licensor You must, to the extent practicable, remove from the Collection any credit as required by Section 4(b), as requested. If You create an Adaptation, upon notice from any Licensor You must, to the extent practicable, remove from the Adaptation any credit as required by Section 4(b), as requested.
-
-     b. If You Distribute, or Publicly Perform the Work or any Adaptations or Collections, You must, unless a request has been made pursuant to Section 4(a), keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or if the Original Author and/or Licensor designate another party or parties (e.g., a sponsor institute, publishing entity, journal) for attribution ("Attribution Parties") in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; (ii) the title of the Work if supplied; (iii) to the extent reasonably practicable, the URI, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and (iv) , consistent with Section 3(b), in the case of an Adaptation, a credit identifying the use of the Work in the Adaptation (e.g., "French translation of the Work by Original Author," or "Screenplay based on original Work by Original Author"). The credit required by this Section 4 (b) may be implemented in any reasonable manner; provided, however, that in the case of a Adaptation or Collection, at a minimum such credit will appear, if a credit for all contributing authors of the Adaptation or Collection appears, then as part of these credits and in a manner at least as prominent as the credits for the other contributing authors. For the avoidance of doubt, You may only use the credit required by this Section for the purpose of attribution in the manner set out above and, by exercising Your rights under this License, You may not implicitly or explicitly assert or imply any connection with, sponsorship or endorsement by the Original Author, Licensor and/or Attribution Parties, as appropriate, of You or Your use of the Work, without the separate, express prior written permission of the Original Author, Licensor and/or Attribution Parties.
-
-     c. Except as otherwise agreed in writing by the Licensor or as may be otherwise permitted by applicable law, if You Reproduce, Distribute or Publicly Perform the Work either by itself or as part of any Adaptations or Collections, You must not distort, mutilate, modify or take other derogatory action in relation to the Work which would be prejudicial to the Original Author's honor or reputation. Licensor agrees that in those jurisdictions (e.g. Japan), in which any exercise of the right granted in Section 3(b) of this License (the right to make Adaptations) would be deemed to be a distortion, mutilation, modification or other derogatory action prejudicial to the Original Author's honor and reputation, the Licensor will waive or not assert, as appropriate, this Section, to the fullest extent permitted by the applicable national law, to enable You to reasonably exercise Your right under Section 3(b) of this License (right to make Adaptations) but not otherwise.
-
-5. Representations, Warranties and Disclaimer
-
-UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.
-
-6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-7. Termination
-
-     a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Adaptations or Collections from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.
-
-     b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.
-
-8. Miscellaneous
-
-     a. Each time You Distribute or Publicly Perform the Work or a Collection, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.
-
-     b. Each time You Distribute or Publicly Perform an Adaptation, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.
-
-     c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
-
-     d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You.
-
-     e. This License may not be modified without the mutual written agreement of the Licensor and You.
-
-     f. The rights granted under, and the subject matter referenced, in this License were drafted utilizing the terminology of the Berne Convention for the Protection of Literary and Artistic Works (as amended on September 28, 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright Convention (as revised on July 24, 1971). These rights and subject matter take effect in the relevant jurisdiction in which the License terms are sought to be enforced according to the corresponding provisions of the implementation of those treaty provisions in the applicable national law. If the standard suite of rights granted under applicable copyright law includes additional rights not granted under this License, such additional rights are deemed to be included in the License; this License is not intended to restrict the license of any rights under applicable law.
-
-Creative Commons Notice
-
-Creative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.
-
-Except for the limited purpose of indicating to the public that the Work is licensed under the CCPL, Creative Commons does not authorize the use by either party of the trademark "Creative Commons" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of this License.
-
-Creative Commons may be contacted at http://creativecommons.org/.

LICENSES/CC-BY-4.0.txt

@@ -1,156 +0,0 @@
-Creative Commons Attribution 4.0 International
-
- Creative Commons Corporation (“Creative Commons”) is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an “as-is” basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.
-
-Using Creative Commons Public Licenses
-
-Creative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.
-
-Considerations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors.
-
-Considerations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor’s permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public.
-
-Creative Commons Attribution 4.0 International Public License
-
-By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.
-
-Section 1 – Definitions.
-
-     a.	Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.
-
-     b.	Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License.
-
-     c.	Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.
-
-     d.	Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.
-
-     e.	Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.
-
-     f.	Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.
-
-     g.	Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.
-
-     h.	Licensor means the individual(s) or entity(ies) granting rights under this Public License.
-
-     i.	Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.
-
-     j.	Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.
-
-     k.	You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.
-
-Section 2 – Scope.
-
-     a.	License grant.
-
-          1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:
-
-               A. reproduce and Share the Licensed Material, in whole or in part; and
-
-               B. produce, reproduce, and Share Adapted Material.
-
-          2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.
-
-          3. Term. The term of this Public License is specified in Section 6(a).
-
-          4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.
-
-          5. Downstream recipients.
-
-               A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.
-
-               B. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.
-
-          6.  No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).
-
-b. Other rights.
-
-          1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.
-
-          2. Patent and trademark rights are not licensed under this Public License.
-
-          3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties.
-
-Section 3 – License Conditions.
-
-Your exercise of the Licensed Rights is expressly made subject to the following conditions.
-
-     a.	Attribution.
-
-          1. If You Share the Licensed Material (including in modified form), You must:
-
-               A. retain the following if it is supplied by the Licensor with the Licensed Material:
-
-                    i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);
-
-                    ii. a copyright notice;
-
-                    iii. a notice that refers to this Public License;
-
-                    iv.	a notice that refers to the disclaimer of warranties;
-
-                    v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;
-
-               B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and
-
-               C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.
-
-          2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.
-
-          3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.
-
-          4. If You Share Adapted Material You produce, the Adapter's License You apply must not prevent recipients of the Adapted Material from complying with this Public License.
-
-Section 4 – Sui Generis Database Rights.
-
-Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:
-
-     a.	for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database;
-
-     b.	if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and
-
-     c.	You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.
-For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.
-
-Section 5 – Disclaimer of Warranties and Limitation of Liability.
-
-     a.	Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.
-
-     b.	To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.
-
-     c.	The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.
-
-Section 6 – Term and Termination.
-
-     a.	This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.
-
-     b.	Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:
-
-          1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or
-
-          2. upon express reinstatement by the Licensor.
-
-     c.	For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.
-
-     d.	For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.
-
-     e.	Sections 1, 5, 6, 7, and 8 survive termination of this Public License.
-
-Section 7 – Other Terms and Conditions.
-
-     a.	The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.
-
-     b.	Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.
-
-Section 8 – Interpretation.
-
-     a.	For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.
-
-     b.	To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.
-
-     c.	No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.
-
-     d.	Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.
-
-Creative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the “Licensor.” Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark “Creative Commons” or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.
-
-Creative Commons may be contacted at creativecommons.org.

LICENSES/CC0-1.0.txt

@@ -1,121 +0,0 @@
-Creative Commons Legal Code
-
-CC0 1.0 Universal
-
-    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
-    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
-    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
-    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
-    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
-    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
-    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
-    HEREUNDER.
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator
-and subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for
-the purpose of contributing to a commons of creative, cultural and
-scientific works ("Commons") that the public can reliably and without fear
-of later claims of infringement build upon, modify, incorporate in other
-works, reuse and redistribute as freely as possible in any form whatsoever
-and for any purposes, including without limitation commercial purposes.
-These owners may contribute to the Commons to promote the ideal of a free
-culture and the further production of creative, cultural and scientific
-works, or to gain reputation or greater distribution for their Work in
-part through the use and efforts of others.
-
-For these and/or other purposes and motivations, and without any
-expectation of additional consideration or compensation, the person
-associating CC0 with a Work (the "Affirmer"), to the extent that he or she
-is an owner of Copyright and Related Rights in the Work, voluntarily
-elects to apply CC0 to the Work and publicly distribute the Work under its
-terms, with knowledge of his or her Copyright and Related Rights in the
-Work and the meaning and intended legal effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not
-limited to, the following:
-
-  i. the right to reproduce, adapt, distribute, perform, display,
-     communicate, and translate a Work;
- ii. moral rights retained by the original author(s) and/or performer(s);
-iii. publicity and privacy rights pertaining to a person's image or
-     likeness depicted in a Work;
- iv. rights protecting against unfair competition in regards to a Work,
-     subject to the limitations in paragraph 4(a), below;
-  v. rights protecting the extraction, dissemination, use and reuse of data
-     in a Work;
- vi. database rights (such as those arising under Directive 96/9/EC of the
-     European Parliament and of the Council of 11 March 1996 on the legal
-     protection of databases, and under any national implementation
-     thereof, including any amended or successor version of such
-     directive); and
-vii. other similar, equivalent or corresponding rights throughout the
-     world based on applicable law or treaty, and any national
-     implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention
-of, applicable law, Affirmer hereby overtly, fully, permanently,
-irrevocably and unconditionally waives, abandons, and surrenders all of
-Affirmer's Copyright and Related Rights and associated claims and causes
-of action, whether now known or unknown (including existing as well as
-future claims and causes of action), in the Work (i) in all territories
-worldwide, (ii) for the maximum duration provided by applicable law or
-treaty (including future time extensions), (iii) in any current or future
-medium and for any number of copies, and (iv) for any purpose whatsoever,
-including without limitation commercial, advertising or promotional
-purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
-member of the public at large and to the detriment of Affirmer's heirs and
-successors, fully intending that such Waiver shall not be subject to
-revocation, rescission, cancellation, termination, or any other legal or
-equitable action to disrupt the quiet enjoyment of the Work by the public
-as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason
-be judged legally invalid or ineffective under applicable law, then the
-Waiver shall be preserved to the maximum extent permitted taking into
-account Affirmer's express Statement of Purpose. In addition, to the
-extent the Waiver is so judged Affirmer hereby grants to each affected
-person a royalty-free, non transferable, non sublicensable, non exclusive,
-irrevocable and unconditional license to exercise Affirmer's Copyright and
-Related Rights in the Work (i) in all territories worldwide, (ii) for the
-maximum duration provided by applicable law or treaty (including future
-time extensions), (iii) in any current or future medium and for any number
-of copies, and (iv) for any purpose whatsoever, including without
-limitation commercial, advertising or promotional purposes (the
-"License"). The License shall be deemed effective as of the date CC0 was
-applied by Affirmer to the Work. Should any part of the License for any
-reason be judged legally invalid or ineffective under applicable law, such
-partial invalidity or ineffectiveness shall not invalidate the remainder
-of the License, and in such case Affirmer hereby affirms that he or she
-will not (i) exercise any of his or her remaining Copyright and Related
-Rights in the Work or (ii) assert any associated claims and causes of
-action with respect to the Work, in either case contrary to Affirmer's
-express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
- a. No trademark or patent rights held by Affirmer are waived, abandoned,
-    surrendered, licensed or otherwise affected by this document.
- b. Affirmer offers the Work as-is and makes no representations or
-    warranties of any kind concerning the Work, express, implied,
-    statutory or otherwise, including without limitation warranties of
-    title, merchantability, fitness for a particular purpose, non
-    infringement, or the absence of latent or other defects, accuracy, or
-    the present or absence of errors, whether or not discoverable, all to
-    the greatest extent permissible under applicable law.
- c. Affirmer disclaims responsibility for clearing rights of other persons
-    that may apply to the Work or any use thereof, including without
-    limitation any person's Copyright and Related Rights in the Work.
-    Further, Affirmer disclaims responsibility for obtaining any necessary
-    consents, permissions or other rights required for any use of the
-    Work.
- d. Affirmer understands and acknowledges that Creative Commons is not a
-    party to this document and has no duty or obligation with respect to
-    this CC0 or use of the Work.

LICENSES/MIT.txt

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) <year> <copyright holders>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSES/MPL-2.0.txt

@@ -1,373 +0,0 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
-    means each individual or legal entity that creates, contributes to
-    the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-    means the combination of the Contributions of others (if any) used
-    by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-    means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-    means Source Code Form to which the initial Contributor has attached
-    the notice in Exhibit A, the Executable Form of such Source Code
-    Form, and Modifications of such Source Code Form, in each case
-    including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-    means
-
-    (a) that the initial Contributor has attached the notice described
-        in Exhibit B to the Covered Software; or
-
-    (b) that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the
-        terms of a Secondary License.
-
-1.6. "Executable Form"
-    means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-    means a work that combines Covered Software with other material, in
-    a separate file or files, that is not Covered Software.
-
-1.8. "License"
-    means this document.
-
-1.9. "Licensable"
-    means having the right to grant, to the maximum extent possible,
-    whether at the time of the initial grant or subsequently, any and
-    all of the rights conveyed by this License.
-
-1.10. "Modifications"
-    means any of the following:
-
-    (a) any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered
-        Software; or
-
-    (b) any new file in Source Code Form that contains any Covered
-        Software.
-
-1.11. "Patent Claims" of a Contributor
-    means any patent claim(s), including without limitation, method,
-    process, and apparatus claims, in any patent Licensable by such
-    Contributor that would be infringed, but for the grant of the
-    License, by the making, using, selling, offering for sale, having
-    made, import, or transfer of either its Contributions or its
-    Contributor Version.
-
-1.12. "Secondary License"
-    means either the GNU General Public License, Version 2.0, the GNU
-    Lesser General Public License, Version 2.1, the GNU Affero General
-    Public License, Version 3.0, or any later versions of those
-    licenses.
-
-1.13. "Source Code Form"
-    means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-    means an individual or a legal entity exercising rights under this
-    License. For legal entities, "You" includes any entity that
-    controls, is controlled by, or is under common control with You. For
-    purposes of this definition, "control" means (a) the power, direct
-    or indirect, to cause the direction or management of such entity,
-    whether by contract or otherwise, or (b) ownership of more than
-    fifty percent (50%) of the outstanding shares or beneficial
-    ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
-    Licensable by such Contributor to use, reproduce, make available,
-    modify, display, perform, distribute, and otherwise exploit its
-    Contributions, either on an unmodified basis, with Modifications, or
-    as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
-    for sale, have made, import, and otherwise transfer either its
-    Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
-    or
-
-(b) for infringements caused by: (i) Your and any other third party's
-    modifications of Covered Software, or (ii) the combination of its
-    Contributions with other software (except as part of its Contributor
-    Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
-    its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
-    Form, as described in Section 3.1, and You must inform recipients of
-    the Executable Form how they can obtain a copy of such Source Code
-    Form by reasonable means in a timely manner, at a charge no more
-    than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
-    License, or sublicense it under different terms, provided that the
-    license for the Executable Form does not attempt to limit or alter
-    the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-*                                                                      *
-*  6. Disclaimer of Warranty                                           *
-*  -------------------------                                           *
-*                                                                      *
-*  Covered Software is provided under this License on an "as is"       *
-*  basis, without warranty of any kind, either expressed, implied, or  *
-*  statutory, including, without limitation, warranties that the       *
-*  Covered Software is free of defects, merchantable, fit for a        *
-*  particular purpose or non-infringing. The entire risk as to the     *
-*  quality and performance of the Covered Software is with You.        *
-*  Should any Covered Software prove defective in any respect, You     *
-*  (not any Contributor) assume the cost of any necessary servicing,   *
-*  repair, or correction. This disclaimer of warranty constitutes an   *
-*  essential part of this License. No use of any Covered Software is   *
-*  authorized under this License except under this disclaimer.         *
-*                                                                      *
-************************************************************************
-
-************************************************************************
-*                                                                      *
-*  7. Limitation of Liability                                          *
-*  --------------------------                                          *
-*                                                                      *
-*  Under no circumstances and under no legal theory, whether tort      *
-*  (including negligence), contract, or otherwise, shall any           *
-*  Contributor, or anyone who distributes Covered Software as          *
-*  permitted above, be liable to You for any direct, indirect,         *
-*  special, incidental, or consequential damages of any character      *
-*  including, without limitation, damages for lost profits, loss of    *
-*  goodwill, work stoppage, computer failure or malfunction, or any    *
-*  and all other commercial damages or losses, even if such party      *
-*  shall have been informed of the possibility of such damages. This   *
-*  limitation of liability shall not apply to liability for death or   *
-*  personal injury resulting from such party's negligence to the       *
-*  extent applicable law prohibits such limitation. Some               *
-*  jurisdictions do not allow the exclusion or limitation of           *
-*  incidental or consequential damages, so this exclusion and          *
-*  limitation may not apply to You.                                    *
-*                                                                      *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
-  This Source Code Form is subject to the terms of the Mozilla Public
-  License, v. 2.0. If a copy of the MPL was not distributed with this
-  file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
-  This Source Code Form is "Incompatible With Secondary Licenses", as
-  defined by the Mozilla Public License, v. 2.0.

README.md

@@ -1,24 +1,40 @@
-<!--
+# ![CC: Tweaked](doc/logo.png)
-SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
+[![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")
 
-SPDX-License-Identifier: MPL-2.0
+CC: Tweaked is a fork of [ComputerCraft](https://github.com/dan200/ComputerCraft), adding programmable computers,
--->
+turtles and more to Minecraft.
 
-<picture>
+## What?
-  <source media="(prefers-color-scheme: dark)" srcset="./doc/logo-darkmode.png">
+ComputerCraft has always held a fond place in my heart: it's the mod which really got me into Minecraft, and it's the
-  <source media="(prefers-color-scheme: light)" srcset="./doc/logo.png">
+mod which has kept me playing it for many years. However, development of the original mod has slowed, as the original
-  <img alt="CC: Tweaked" src="./doc/logo.png">
+developers have had less time to work on the mod, and moved onto other projects and commitments.
-</picture>
 
-[![Current build status](https://github.com/cc-tweaked/CC-Tweaked/workflows/Build/badge.svg)](https://github.com/cc-tweaked/CC-Tweaked/actions "Current build status")
+CC: Tweaked (or CC:T for short) is an attempt to continue ComputerCraft's legacy. It's not intended to be a competitor
-[![Download CC: Tweaked on CurseForge](https://img.shields.io/static/v1?label=Download&message=CC:%20Tweaked&color=E04E14&logoColor=E04E14&logo=CurseForge)][CurseForge]
+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
-[![Download CC: Tweaked on Modrinth](https://img.shields.io/static/v1?label=Download&color=00AF5C&logoColor=00AF5C&logo=Modrinth&message=CC:%20Tweaked)][Modrinth]
+ComputerCraft experience as _solid_ as possible, ironing out any wrinkles that may have developed over time.
 
-CC: Tweaked is a mod for Minecraft which adds programmable computers, turtles and more to the game. A fork of the
+## Features
-much-beloved [ComputerCraft], it continues its legacy with improved performance and stability, along with a wealth of
+CC: Tweaked contains all the features of the latest version of ComputerCraft, as well as numerous fixes, performance
-new features.
+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:
 
-CC: Tweaked can be installed from [CurseForge] or [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
+ - 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. If you want to get started
@@ -26,10 +42,12 @@ developing the mod, [check out the instructions here](CONTRIBUTING.md#developing
 
 ## Community
 If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
-ComputerCraft, do check out our [forum] and [GitHub discussions page][GitHub discussions]! There's also a fairly
+ComputerCraft we have a [forum](https://forums.computercraft.cc/) and [Discord guild](https://discord.computercraft.cc)!
-populated, albeit quiet [IRC channel][irc], if that's more your cup of tea.
+There's also a fairly populated, albeit quiet [IRC channel](http://webchat.esper.net/?channels=computercraft), if that's
+more your cup of tea.
 
-We also host fairly comprehensive documentation at [tweaked.cc](https://tweaked.cc/ "The CC: Tweaked website").
+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
 CC: Tweaked is hosted on my maven repo, and so is relatively simple to depend on. You may wish to add a soft (or hard)
@@ -38,54 +56,17 @@ on is present.
 
 ```groovy
 repositories {
-  maven {
+  maven { url 'https://squiddev.cc/maven/' }
-    url "https://squiddev.cc/maven/"
-    content {
-      includeGroup("cc.tweaked")
-    }
-  }
 }
 
 dependencies {
-  // Vanilla (i.e. for multi-loader systems)
+  implementation fg.deobf("org.squiddev:cc-tweaked-${mc_version}:${cct_version}")
-  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-common-api:$cctVersion")
-
-  // Forge Gradle
-  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-core-api:$cctVersion")
-  compileOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion"))
-  runtimeOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion"))
-
-  // Fabric Loom
-  modCompileOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric-api:$cctVersion")
-  modRuntimeOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric:$cctVersion")
-}
-```
-
-When using ForgeGradle, you may also need to add the following:
-
-```groovy
-minecraft {
-    runs {
-        configureEach {
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
-        }
-    }
 }
 ```
 
 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 (or need to mixin to CC:T), please file
+subject to change at any point. If you depend on functionality outside the API, file an issue, and we can look into
-an issue to let me know!
+exposing more features.
 
 We bundle the API sources with the jar, so documentation should be easily viewable within your editor. Alternatively,
 the generated documentation [can be browsed online](https://tweaked.cc/javadoc/).
-
-[computercraft]: https://github.com/dan200/ComputerCraft "ComputerCraft on GitHub"
-[curseforge]: https://minecraft.curseforge.com/projects/cc-tweaked "Download CC: Tweaked from CurseForge"
-[modrinth]: https://modrinth.com/mod/gu7yAYhd "Download CC: Tweaked from Modrinth"
-[Minecraft Forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
-[Fabric]: https://fabricmc.net/use/installer/ "Download Fabric."
-[forum]: https://forums.computercraft.cc/
-[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"

build.gradle

@@ -0,0 +1,564 @@
+buildscript {
+    repositories {
+        mavenCentral()
+        maven {
+            name = "forge"
+            url = "https://maven.minecraftforge.net"
+        }
+    }
+    dependencies {
+        classpath 'com.google.code.gson:gson:2.8.1'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:5.0.6'
+    }
+}
+
+plugins {
+    id "checkstyle"
+    id "jacoco"
+    id "maven-publish"
+    id "com.github.hierynomus.license" version "0.16.1"
+    id "com.matthewprenger.cursegradle" version "1.4.0"
+    id "com.github.breadmoirai.github-release" version "2.2.12"
+    id "org.jetbrains.kotlin.jvm" version "1.3.72"
+    id "com.modrinth.minotaur" version "1.2.1"
+}
+
+apply plugin: 'net.minecraftforge.gradle'
+
+version = mod_version
+
+group = "org.squiddev"
+archivesBaseName = "cc-tweaked-${mc_version}"
+
+def javaVersion = JavaLanguageVersion.of(8)
+java {
+    toolchain {
+        languageVersion = javaVersion
+    }
+
+    withSourcesJar()
+    withJavadocJar()
+}
+
+// Tragically java.toolchain.languageVersion doesn't apply to ForgeGradle's
+// tasks, so we force all launchers to use the right Java version.
+tasks.withType(JavaCompile).configureEach {
+    javaCompiler = javaToolchains.compilerFor {
+        languageVersion = javaVersion
+    }
+}
+
+tasks.withType(JavaExec).configureEach {
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion = javaVersion
+    }
+}
+
+minecraft {
+    runs {
+        client {
+            workingDirectory project.file('run')
+            property 'forge.logging.markers', 'REGISTRIES'
+            property 'forge.logging.console.level', 'debug'
+
+            mods {
+                computercraft {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        server {
+            workingDirectory project.file("run/server")
+            property 'forge.logging.markers', 'REGISTRIES'
+            property 'forge.logging.console.level', 'debug'
+            arg "--nogui"
+
+            mods {
+                computercraft {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        data {
+            workingDirectory project.file('run')
+            property 'forge.logging.markers', 'REGISTRIES'
+            property 'forge.logging.console.level', 'debug'
+
+            args '--mod', 'computercraft', '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
+            mods {
+                computercraft {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        testServer {
+            workingDirectory project.file('test-files/server')
+            parent runs.server
+
+            mods {
+                cctest {
+                    source sourceSets.test
+                }
+            }
+        }
+    }
+
+    mappings channel: 'official', version: project.mc_version
+
+    accessTransformer file('src/main/resources/META-INF/accesstransformer.cfg')
+}
+
+sourceSets {
+    main.resources {
+        srcDir 'src/generated/resources'
+    }
+}
+
+repositories {
+    mavenCentral()
+    maven {
+        name "SquidDev"
+        url "https://squiddev.cc/maven"
+    }
+}
+
+configurations {
+    shade
+    compile.extendsFrom shade
+    cctJavadoc
+}
+
+dependencies {
+    checkstyle "com.puppycrawl.tools:checkstyle:8.25"
+
+    minecraft "net.minecraftforge:forge:${mc_version}-${forge_version}"
+
+    compileOnly fg.deobf("mezz.jei:jei-1.15.2:6.0.0.3:api")
+    compileOnly fg.deobf("com.blamejared.crafttweaker:CraftTweaker-1.15.2:6.0.0.9")
+
+    runtimeOnly fg.deobf("mezz.jei:jei-1.15.2:6.0.0.3")
+
+    shade 'org.squiddev:Cobalt:0.5.2-SNAPSHOT'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
+    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.7.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
+    testImplementation 'org.hamcrest:hamcrest:2.2'
+    testImplementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.3.72'
+    testImplementation 'org.jetbrains.kotlin:kotlin-reflect:1.3.72'
+    testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.8'
+
+    cctJavadoc 'cc.tweaked:cct-javadoc:1.4.0'
+}
+
+// Compile tasks
+
+javadoc {
+    include "dan200/computercraft/api/**/*.java"
+}
+
+task luaJavadoc(type: Javadoc) {
+    description "Generates documentation for Java-side Lua functions."
+    group "documentation"
+
+    source = sourceSets.main.allJava
+    destinationDir = file("${project.docsDir}/luaJavadoc")
+    classpath = sourceSets.main.compileClasspath
+
+    options.docletpath = configurations.cctJavadoc.files as List
+    options.doclet = "cc.tweaked.javadoc.LuaDoclet"
+    options.noTimestamp = false
+
+    javadocTool = javaToolchains.javadocToolFor {
+        languageVersion = JavaLanguageVersion.of(11)
+    }
+}
+
+jar {
+    manifest {
+        attributes(["Specification-Title": "computercraft",
+                    "Specification-Vendor": "SquidDev",
+                    "Specification-Version": "1",
+                    "Implementation-Title": "CC: Tweaked",
+                    "Implementation-Version": "${mod_version}",
+                    "Implementation-Vendor" :"SquidDev",
+                    "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")])
+    }
+
+    from configurations.shade.collect { it.isDirectory() ? it : zipTree(it) }
+}
+
+[compileJava, compileTestJava].forEach {
+    it.configure {
+        options.compilerArgs << "-Xlint" << "-Xlint:-processing"
+    }
+}
+
+processResources {
+    inputs.property "version", mod_version
+    inputs.property "mcversion", mc_version
+
+    def hash = 'none'
+    Set<String> contributors = []
+    try {
+        hash = ["git", "-C", projectDir, "rev-parse", "HEAD"].execute().text.trim()
+
+        def blacklist = ['GitHub', 'dan200', 'Daniel Ratcliffe']
+        ["git", "-C", projectDir, "log", "--format=tformat:%an%n%cn"].execute().text.split('\n').each {
+            if (!blacklist.contains(it)) contributors.add(it)
+        }
+    } catch(Exception e) {
+        e.printStackTrace()
+    }
+    inputs.property "commithash", hash
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
+
+    from(sourceSets.main.resources.srcDirs) {
+        include 'META-INF/mods.toml'
+        include 'data/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 'META-INF/mods.toml'
+        exclude 'data/computercraft/lua/rom/help/credits.txt'
+    }
+}
+
+sourcesJar {
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
+}
+
+// Web tasks
+
+import org.apache.tools.ant.taskdefs.condition.Os
+
+List<String> mkCommand(String command) {
+    return Os.isFamily(Os.FAMILY_WINDOWS) ? ["cmd", "/c", command] : ["sh", "-c", command]
+}
+
+task rollup(type: Exec) {
+    group = "build"
+    description = "Bundles JS into rollup"
+
+    inputs.files(fileTree("src/web")).withPropertyName("sources")
+    inputs.file("package-lock.json").withPropertyName("package-lock.json")
+    inputs.file("tsconfig.json").withPropertyName("Typescript config")
+    inputs.file("rollup.config.js").withPropertyName("Rollup config")
+    outputs.file("$buildDir/rollup/index.js").withPropertyName("output")
+
+    commandLine mkCommand('"node_modules/.bin/rollup" --config rollup.config.js')
+}
+
+task minifyWeb(type: Exec, dependsOn: rollup) {
+    group = "build"
+    description = "Bundles JS into rollup"
+
+    inputs.file("$buildDir/rollup/index.js").withPropertyName("sources")
+    inputs.file("package-lock.json").withPropertyName("package-lock.json")
+    outputs.file("$buildDir/rollup/index.min.js").withPropertyName("output")
+
+    commandLine mkCommand('"node_modules/.bin/terser"' + " -o '$buildDir/rollup/index.min.js' '$buildDir/rollup/index.js'")
+}
+
+task illuaminateDocs(type: Exec, dependsOn: [minifyWeb, luaJavadoc]) {
+    group = "build"
+    description = "Bundles JS into rollup"
+
+    inputs.files(fileTree("doc")).withPropertyName("docs")
+    inputs.files(fileTree("src/main/resources/data/computercraft/lua/rom")).withPropertyName("lua rom")
+    inputs.file("illuaminate.sexp").withPropertyName("illuaminate.sexp")
+    inputs.dir("$buildDir/docs/luaJavadoc")
+    inputs.file("$buildDir/rollup/index.min.js").withPropertyName("scripts")
+    inputs.file("src/web/styles.css").withPropertyName("styles")
+    outputs.dir("$buildDir/docs/lua")
+
+    commandLine mkCommand('"bin/illuaminate" doc-gen')
+}
+
+task docWebsite(type: Copy, dependsOn: [illuaminateDocs]) {
+    from 'doc/logo.png'
+    into "${project.docsDir}/lua"
+}
+
+// Check tasks
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events "skipped", "failed"
+    }
+}
+
+jacocoTestReport {
+    dependsOn('test')
+    reports {
+        xml.enabled true
+        html.enabled true
+    }
+}
+
+check.dependsOn jacocoTestReport
+
+
+import com.hierynomus.gradle.license.tasks.LicenseCheck
+import com.hierynomus.gradle.license.tasks.LicenseFormat
+
+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 file('config/license/main.txt')
+    }
+}
+
+[licenseTest, licenseFormatTest].forEach {
+    it.configure {
+        include("**/*.java")
+        header 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 file('config/license/api.txt')
+    }
+}
+
+task setupServer(type: Copy) {
+    group "test server"
+    description "Sets up the environment for the test server."
+
+    from("src/test/server-files") {
+        include "eula.txt"
+        include "server.properties"
+    }
+    into "test-files/server"
+}
+
+tasks.register('testInGame', JavaExec.class).configure {
+    it.group('test server')
+    it.description("Runs tests on a temporary Minecraft server.")
+    it.dependsOn(setupServer, 'prepareRunTestServer', 'cleanTestInGame')
+
+    // Copy from runTestServer. We do it in this slightly odd way as runTestServer
+    // isn't created until the task is configured (which is no good for us).
+    JavaExec exec = tasks.getByName('runTestServer')
+    it.setWorkingDir(exec.getWorkingDir())
+    it.setSystemProperties(exec.getSystemProperties())
+    it.setBootstrapClasspath(exec.getBootstrapClasspath())
+    it.setClasspath(exec.getClasspath())
+    it.setMain(exec.getMain())
+    it.setEnvironment(exec.getEnvironment())
+    it.setArgs(exec.getArgs())
+    it.setJvmArgs(exec.getJvmArgs())
+
+    it.systemProperty('forge.logging.console.level', 'info')
+    it.systemProperty('cctest.run', 'true')
+
+    // Jacoco and modlauncher don't play well together as the classes loaded in-game don't
+    // match up with those written to disk. We get Jacoco to dump all classes to disk, and
+    // use that when generating the report.
+    def coverageOut = new File(buildDir, 'jacocoClassDump/testInGame')
+    jacoco.applyTo(it)
+    it.jacoco.setIncludes(["dan200.computercraft.*"])
+    it.jacoco.setClassDumpDir(coverageOut)
+    it.outputs.dir(coverageOut)
+    // Older versions of modlauncher don't include a protection domain (and thus no code
+    // source). Jacoco skips such classes by default, so we need to explicitly include them.
+    it.jacoco.setIncludeNoLocationClasses(true)
+}
+
+tasks.register('jacocoTestInGameReport', JacocoReport.class).configure {
+    it.group('test server')
+    it.description('Generate coverage reports for in-game tests (testInGame)')
+    it.dependsOn('testInGame')
+
+    it.executionData(new File(buildDir, 'jacoco/testInGame.exec'))
+    it.sourceDirectories.from(sourceSets.main.allJava.srcDirs)
+    it.classDirectories.from(new File(buildDir, 'jacocoClassDump/testInGame'))
+
+    it.reports {
+        xml.enabled true
+        html.enabled true
+    }
+}
+check.dependsOn('jacocoTestInGameReport')
+
+
+// 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/data/computercraft/lua/rom/help/changelog.md")
+    inputs.file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
+
+    doLast {
+        def ok = true
+
+        // Check we're targetting the current version
+        def whatsnew = new File(projectDir, "src/main/resources/data/computercraft/lua/rom/help/whatsnew.md").readLines()
+        if (whatsnew[0] != "New features in CC: Tweaked $mod_version") {
+            ok = false
+            project.logger.error("Expected `whatsnew.md' 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.md")
+        } else {
+            whatsnew = whatsnew.getAt(0 ..< idx)
+        }
+
+        // Check whatsnew and changelog match.
+        def versionChangelog = "# " + whatsnew.join("\n")
+        def changelog = new File(projectDir, "src/main/resources/data/computercraft/lua/rom/help/changelog.md").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"
+        }
+    }
+}
+
+import com.modrinth.minotaur.TaskModrinthUpload
+tasks.register('publishModrinth', TaskModrinthUpload.class).configure {
+    dependsOn('assemble', 'reobfJar')
+    onlyIf {
+        project.hasProperty('modrinthApiKey')
+    }
+
+    token = project.hasProperty('modrinthApiKey') ? project.getProperty('modrinthApiKey') : ''
+    projectId = 'gu7yAYhd'
+    versionNumber = "${project.mc_version}-${project.mod_version}"
+    uploadFile = jar
+    addGameVersion(project.mc_version)
+    changelog = "Release notes can be found on the [GitHub repository](https://github.com/SquidDev-CC/CC-Tweaked/releases/tag/v${mc_version}-${mod_version})."
+    addLoader('forge')
+}
+
+tasks.withType(GenerateModuleMetadata) {
+    // We can't generate metadata as that includes Forge as a dependency.
+    enabled = false
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from components.java
+
+            pom {
+                name = 'CC: Tweaked'
+                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/mc-1.15.x/LICENSE'
+                    }
+                }
+
+                withXml { asNode().remove(asNode().get("dependencies")) }
+            }
+        }
+    }
+
+    repositories {
+        if (project.hasProperty("mavenUser")) {
+            maven {
+                name = "SquidDev"
+                url = "https://squiddev.cc/maven"
+                credentials {
+                    username = project.property("mavenUser") as String
+                    password = project.property("mavenPass") as String
+                }
+            }
+        }
+    }
+}
+
+githubRelease {
+    token project.hasProperty('githubApiKey') ? project.githubApiKey : ''
+    owner 'SquidDev-CC'
+    repo 'CC-Tweaked'
+    targetCommitish.set(project.provider({
+        try {
+            return ["git", "-C", projectDir, "rev-parse", "--abbrev-ref", "HEAD"].execute().text.trim()
+        } catch (Exception e) {
+            e.printStackTrace()
+        }
+        return "master"
+    }))
+
+    tagName "v${mc_version}-${mod_version}"
+    releaseName "[${mc_version}] ${mod_version}"
+    body.set(project.provider({
+        "## " + new File(projectDir, "src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
+            .readLines()
+            .takeWhile { it != 'Type "help changelog" to see the full version history.' }
+            .join("\n").trim()
+    }))
+    prerelease false
+}
+
+def uploadTasks = ["publish", "curseforge", "publishModrinth", "githubRelease"]
+uploadTasks.forEach { tasks.getByName(it).dependsOn checkRelease }
+
+task uploadAll(dependsOn: uploadTasks) {
+    group "upload"
+    description "Uploads to all repositories (Maven, Curse, Modrinth, GitHub release)"
+}

build.gradle.kts

@@ -1,112 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-import cc.tweaked.gradle.JUnitExt
-import net.fabricmc.loom.api.LoomGradleExtensionAPI
-import net.fabricmc.loom.util.gradle.SourceSetHelper
-import org.jetbrains.gradle.ext.compiler
-import org.jetbrains.gradle.ext.runConfigurations
-import org.jetbrains.gradle.ext.settings
-
-plugins {
-    publishing
-    alias(libs.plugins.taskTree)
-    alias(libs.plugins.githubRelease)
-    alias(libs.plugins.gradleVersions)
-    alias(libs.plugins.versionCatalogUpdate)
-    id("org.jetbrains.gradle.plugin.idea-ext")
-    id("cc-tweaked")
-}
-
-val isUnstable = project.properties["isUnstable"] == "true"
-val modVersion: String by extra
-val mcVersion: String by extra
-
-githubRelease {
-    token(findProperty("githubApiKey") as String? ?: "")
-    owner.set("cc-tweaked")
-    repo.set("CC-Tweaked")
-    targetCommitish.set(cct.gitBranch)
-
-    tagName.set("v$mcVersion-$modVersion")
-    releaseName.set("[$mcVersion] $modVersion")
-    body.set(
-        provider {
-            "## " + project(":core").file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
-                .readLines()
-                .takeWhile { it != "Type \"help changelog\" to see the full version history." }
-                .joinToString("\n").trim()
-        },
-    )
-    prerelease.set(isUnstable)
-}
-
-tasks.publish { dependsOn(tasks.githubRelease) }
-
-idea.project.settings.runConfigurations {
-    register<JUnitExt>("Core Tests") {
-        vmParameters = "-ea"
-        moduleName = "${idea.project.name}.core.test"
-        packageName = ""
-    }
-
-    register<JUnitExt>("CraftOS Tests") {
-        vmParameters = "-ea"
-        moduleName = "${idea.project.name}.core.test"
-        className = "dan200.computercraft.core.ComputerTestDelegate"
-    }
-
-    register<JUnitExt>("CraftOS Tests (Fast)") {
-        vmParameters = "-ea -Dcc.skip_keywords=slow"
-        moduleName = "${idea.project.name}.core.test"
-        className = "dan200.computercraft.core.ComputerTestDelegate"
-    }
-
-    register<JUnitExt>("Common Tests") {
-        vmParameters = "-ea"
-        moduleName = "${idea.project.name}.common.test"
-        packageName = ""
-    }
-
-    register<JUnitExt>("Fabric Tests") {
-        val fabricProject = evaluationDependsOn(":fabric")
-        val classPathGroup = fabricProject.extensions.getByType<LoomGradleExtensionAPI>().mods
-            .joinToString(File.pathSeparator + File.pathSeparator) { modSettings ->
-                SourceSetHelper.getClasspath(modSettings, project).joinToString(File.pathSeparator) { it.absolutePath }
-            }
-
-        vmParameters = "-ea -Dfabric.classPathGroups=$classPathGroup"
-        moduleName = "${idea.project.name}.fabric.test"
-        packageName = ""
-    }
-
-    register<JUnitExt>("Forge Tests") {
-        vmParameters = "-ea"
-        moduleName = "${idea.project.name}.forge.test"
-        packageName = ""
-    }
-}
-
-idea.project.settings.compiler.javac {
-    // We want ErrorProne to be present when compiling via IntelliJ, as it offers some helpful warnings
-    // and errors. Loop through our source sets and find the appropriate flags.
-    moduleJavacAdditionalOptions = subprojects
-        .asSequence()
-        .map { evaluationDependsOn(it.path) }
-        .flatMap { project ->
-            val sourceSets = project.extensions.findByType(SourceSetContainer::class) ?: return@flatMap sequenceOf()
-            sourceSets.asSequence().map { sourceSet ->
-                val name = "${idea.project.name}.${project.name}.${sourceSet.name}"
-                val compile = project.tasks.named(sourceSet.compileJavaTaskName, JavaCompile::class).get()
-                name to compile.options.allCompilerArgs.joinToString(" ") { if (it.contains(" ")) "\"$it\"" else it }
-            }
-        }
-        .toMap()
-}
-
-versionCatalogUpdate {
-    sortByKey.set(false)
-    pin { versions.addAll("fastutil", "guava", "netty", "slf4j") }
-    keep { keepUnusedLibraries.set(true) }
-}

buildSrc/build.gradle.kts

@@ -1,84 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-plugins {
-    `java-gradle-plugin`
-    `kotlin-dsl`
-    alias(libs.plugins.gradleVersions)
-    alias(libs.plugins.versionCatalogUpdate)
-}
-
-// Duplicated in settings.gradle.kts
-repositories {
-    mavenCentral()
-    gradlePluginPortal()
-
-    maven("https://maven.minecraftforge.net") {
-        name = "Forge"
-        content {
-            includeGroup("net.minecraftforge")
-            includeGroup("net.minecraftforge.gradle")
-        }
-    }
-
-    maven("https://maven.parchmentmc.org") {
-        name = "Librarian"
-        content {
-            includeGroupByRegex("^org\\.parchmentmc.*")
-        }
-    }
-
-    maven("https://maven.fabricmc.net/") {
-        name = "Fabric"
-        content {
-            includeGroup("net.fabricmc")
-        }
-    }
-
-    maven("https://squiddev.cc/maven") {
-        name = "SquidDev"
-        content {
-            includeGroup("cc.tweaked.vanilla-extract")
-        }
-    }
-}
-
-dependencies {
-    implementation(libs.errorProne.plugin)
-    implementation(libs.kotlin.plugin)
-    implementation(libs.spotless)
-
-    implementation(libs.curseForgeGradle)
-    implementation(libs.fabric.loom)
-    implementation(libs.forgeGradle)
-    implementation(libs.ideaExt)
-    implementation(libs.librarian)
-    implementation(libs.minotaur)
-    implementation(libs.vanillaExtract)
-}
-
-gradlePlugin {
-    plugins {
-        register("cc-tweaked") {
-            id = "cc-tweaked"
-            implementationClass = "cc.tweaked.gradle.CCTweakedPlugin"
-        }
-
-        register("cc-tweaked.illuaminate") {
-            id = "cc-tweaked.illuaminate"
-            implementationClass = "cc.tweaked.gradle.IlluaminatePlugin"
-        }
-
-        register("cc-tweaked.node") {
-            id = "cc-tweaked.node"
-            implementationClass = "cc.tweaked.gradle.NodePlugin"
-        }
-    }
-}
-
-versionCatalogUpdate {
-    sortByKey.set(false)
-    keep { keepUnusedLibraries.set(true) }
-    catalogFile.set(file("../gradle/libs.versions.toml"))
-}

buildSrc/settings.gradle.kts

@@ -1,11 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-dependencyResolutionManagement {
-    versionCatalogs {
-        create("libs") {
-            from(files("../gradle/libs.versions.toml"))
-        }
-    }
-}

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

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

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

@@ -1,44 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-/** Default configuration for Forge projects. */
-
-import cc.tweaked.gradle.CCTweakedExtension
-import cc.tweaked.gradle.CCTweakedPlugin
-import cc.tweaked.gradle.IdeaRunConfigurations
-import cc.tweaked.gradle.MinecraftConfigurations
-
-plugins {
-    id("net.minecraftforge.gradle")
-    // We must apply java-convention after Forge, as we need the fg extension to be present.
-    id("cc-tweaked.java-convention")
-    id("org.parchmentmc.librarian.forgegradle")
-}
-
-plugins.apply(CCTweakedPlugin::class.java)
-
-val mcVersion: String by extra
-
-minecraft {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    mappings("parchment", "${libs.findVersion("parchmentMc").get()}-${libs.findVersion("parchment").get()}-$mcVersion")
-
-    accessTransformer(project(":forge").file("src/main/resources/META-INF/accesstransformer.cfg"))
-}
-
-MinecraftConfigurations.setup(project)
-
-extensions.configure(CCTweakedExtension::class.java) {
-    linters(minecraft = true, loader = "forge")
-}
-
-dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    "minecraft"("net.minecraftforge:forge:$mcVersion-${libs.findVersion("forge").get()}")
-}
-
-tasks.configureEach {
-    // genIntellijRuns isn't registered until much later, so we need this silly hijinks.
-    if (name == "genIntellijRuns") doLast { IdeaRunConfigurations(project).patch() }
-}

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

@@ -1,64 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-import cc.tweaked.gradle.clientClasses
-import cc.tweaked.gradle.commonClasses
-
-/**
- * Sets up the configurations for writing game tests.
- *
- * See notes in [cc.tweaked.gradle.MinecraftConfigurations] for the general design behind these cursed ideas.
- */
-
-plugins {
-    id("cc-tweaked.kotlin-convention")
-    id("cc-tweaked.java-convention")
-}
-
-val main = sourceSets["main"]
-val client = sourceSets["client"]
-
-// Both testMod and testFixtures inherit from the main and client classpath, just so we have access to Minecraft classes.
-val testMod by sourceSets.creating {
-    compileClasspath += main.compileClasspath + client.compileClasspath
-    runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
-}
-
-configurations {
-    named(testMod.compileClasspathConfigurationName) {
-        shouldResolveConsistentlyWith(compileClasspath.get())
-    }
-
-    named(testMod.runtimeClasspathConfigurationName) {
-        shouldResolveConsistentlyWith(runtimeClasspath.get())
-    }
-}
-
-// Like the main test configurations, we're safe to depend on source set outputs.
-dependencies {
-    add(testMod.implementationConfigurationName, main.output)
-    add(testMod.implementationConfigurationName, client.output)
-}
-
-// Similar to java-test-fixtures, but tries to avoid putting the obfuscated jar on the classpath.
-
-val testFixtures by sourceSets.creating {
-    compileClasspath += main.compileClasspath + client.compileClasspath
-}
-
-java.registerFeature("testFixtures") {
-    usingSourceSet(testFixtures)
-    disablePublication()
-}
-
-dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    add(testFixtures.apiConfigurationName, libs.findBundle("test").get())
-    // Consumers of this project already have the common and client classes on the classpath, so it's fine for these
-    // to be compile-only.
-    add(testFixtures.compileOnlyApiConfigurationName, commonClasses(project))
-    add(testFixtures.compileOnlyApiConfigurationName, clientClasses(project))
-
-    testImplementation(testFixtures(project))
-}

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

@@ -1,231 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-import cc.tweaked.gradle.CCTweakedExtension
-import cc.tweaked.gradle.CCTweakedPlugin
-import com.diffplug.gradle.spotless.FormatExtension
-import com.diffplug.spotless.LineEnding
-import net.ltgt.gradle.errorprone.CheckSeverity
-import net.ltgt.gradle.errorprone.errorprone
-import java.nio.charset.StandardCharsets
-
-plugins {
-    `java-library`
-    idea
-    jacoco
-    checkstyle
-    id("com.diffplug.spotless")
-    id("net.ltgt.errorprone")
-}
-
-val modVersion: String by extra
-val mcVersion: String by extra
-
-group = "cc.tweaked"
-version = modVersion
-
-base.archivesName.convention("cc-tweaked-$mcVersion-${project.name}")
-
-java {
-    toolchain {
-        languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
-    }
-
-    withSourcesJar()
-}
-
-repositories {
-    mavenCentral()
-
-    val mainMaven = maven("https://squiddev.cc/maven") {
-        name = "SquidDev"
-    }
-
-    exclusiveContent {
-        forRepositories(mainMaven)
-
-        // Include the ForgeGradle repository if present. This requires that ForgeGradle is already present, which we
-        // enforce in our Forge overlay.
-        val fg =
-            project.extensions.findByType(net.minecraftforge.gradle.userdev.DependencyManagementExtension::class.java)
-        if (fg != null) forRepositories(fg.repository)
-
-        filter {
-            includeGroup("cc.tweaked")
-            // Things we mirror
-            includeGroup("commoble.morered")
-            includeGroup("dev.architectury")
-            includeGroup("dev.emi")
-            includeGroup("maven.modrinth")
-            includeGroup("me.shedaniel.cloth")
-            includeGroup("me.shedaniel")
-            includeGroup("mezz.jei")
-            includeGroup("org.teavm")
-            includeModule("com.terraformersmc", "modmenu")
-            includeModule("me.lucko", "fabric-permissions-api")
-        }
-    }
-}
-
-dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    checkstyle(libs.findLibrary("checkstyle").get())
-
-    constraints {
-        checkstyle("org.codehaus.plexus:plexus-container-default:2.1.1") {
-            because("2.1.0 depends on deprecated Google collections module")
-        }
-    }
-
-    errorprone(libs.findLibrary("errorProne-core").get())
-    errorprone(libs.findLibrary("nullAway").get())
-}
-
-// Configure default JavaCompile tasks with our arguments.
-sourceSets.all {
-    tasks.named(compileJavaTaskName, JavaCompile::class.java) {
-        // Processing just gives us "No processor claimed any of these annotations", so skip that!
-        options.compilerArgs.addAll(listOf("-Xlint", "-Xlint:-processing"))
-
-        options.errorprone {
-            check("InvalidBlockTag", CheckSeverity.OFF) // Broken by @cc.xyz
-            check("InvalidParam", CheckSeverity.OFF) // Broken by records.
-            check("InlineMeSuggester", CheckSeverity.OFF) // Minecraft uses @Deprecated liberally
-            // Too many false positives right now. Maybe we need an indirection for it later on.
-            check("ReferenceEquality", CheckSeverity.OFF)
-            check("UnusedVariable", CheckSeverity.OFF) // Too many false positives with records.
-            check("OperatorPrecedence", CheckSeverity.OFF) // For now.
-            check("AlreadyChecked", CheckSeverity.OFF) // Seems to be broken?
-            check("NonOverridingEquals", CheckSeverity.OFF) // Peripheral.equals makes this hard to avoid
-            check("FutureReturnValueIgnored", CheckSeverity.OFF) // Too many false positives with Netty
-
-            check("NullAway", CheckSeverity.ERROR)
-            option(
-                "NullAway:AnnotatedPackages",
-                listOf("dan200.computercraft", "cc.tweaked", "net.fabricmc.fabric.api").joinToString(","),
-            )
-            option("NullAway:ExcludedFieldAnnotations", listOf("org.spongepowered.asm.mixin.Shadow").joinToString(","))
-            option("NullAway:CastToNonNullMethod", "dan200.computercraft.core.util.Nullability.assertNonNull")
-            option("NullAway:CheckOptionalEmptiness")
-            option("NullAway:AcknowledgeRestrictiveAnnotations")
-
-            excludedPaths = ".*/jmh_generated/.*"
-        }
-    }
-}
-
-tasks.compileTestJava {
-    options.errorprone {
-        check("NullAway", CheckSeverity.OFF)
-    }
-}
-
-
-tasks.withType(JavaCompile::class.java).configureEach {
-    options.encoding = "UTF-8"
-}
-
-tasks.processResources {
-    exclude("**/*.license")
-    exclude(".cache")
-}
-
-tasks.withType(AbstractArchiveTask::class.java).configureEach {
-    isPreserveFileTimestamps = false
-    isReproducibleFileOrder = true
-    dirMode = Integer.valueOf("755", 8)
-    fileMode = Integer.valueOf("664", 8)
-}
-
-tasks.jar {
-    manifest {
-        attributes(
-            "Specification-Title" to "computercraft",
-            "Specification-Vendor" to "SquidDev",
-            "Specification-Version" to "1",
-            "Implementation-Title" to "cctweaked-${project.name}",
-            "Implementation-Version" to modVersion,
-            "Implementation-Vendor" to "SquidDev",
-        )
-    }
-}
-
-tasks.javadoc {
-    options {
-        val stdOptions = this as StandardJavadocDocletOptions
-        stdOptions.addBooleanOption("Xdoclint:all,-missing", true)
-        stdOptions.links("https://docs.oracle.com/en/java/javase/17/docs/api/")
-    }
-}
-
-tasks.test {
-    finalizedBy("jacocoTestReport")
-
-    useJUnitPlatform()
-    testLogging {
-        events("skipped", "failed")
-    }
-}
-
-tasks.withType(JacocoReport::class.java).configureEach {
-    reports.xml.required.set(true)
-    reports.html.required.set(true)
-}
-
-project.plugins.withType(CCTweakedPlugin::class.java) {
-    // Set up jacoco to read from /all/ our source directories.
-    val cct = project.extensions.getByType<CCTweakedExtension>()
-    project.tasks.named("jacocoTestReport", JacocoReport::class.java) {
-        for (ref in cct.sourceSets.get()) sourceDirectories.from(ref.allSource.sourceDirectories)
-    }
-}
-
-tasks.register("checkstyle") {
-    description = "Run Checkstyle on all sources"
-    group = LifecycleBasePlugin.VERIFICATION_GROUP
-    dependsOn(tasks.withType(Checkstyle::class.java))
-}
-
-spotless {
-    encoding = StandardCharsets.UTF_8
-    lineEndings = LineEnding.UNIX
-
-    fun FormatExtension.defaults() {
-        endWithNewline()
-        trimTrailingWhitespace()
-        indentWithSpaces(4)
-    }
-
-    java {
-        defaults()
-        removeUnusedImports()
-    }
-
-    val ktlintConfig = mapOf(
-        "ktlint_standard_no-wildcard-imports" to "disabled",
-        "ktlint_standard_class-naming" to "disabled",
-        "ktlint_standard_function-naming" to "disabled",
-        "ij_kotlin_allow_trailing_comma" to "true",
-        "ij_kotlin_allow_trailing_comma_on_call_site" to "true",
-    )
-
-    kotlinGradle {
-        defaults()
-        ktlint().editorConfigOverride(ktlintConfig)
-    }
-
-    kotlin {
-        defaults()
-        ktlint().editorConfigOverride(ktlintConfig)
-    }
-}
-
-idea.module {
-    excludeDirs.addAll(project.files("run", "out", "logs").files)
-
-    // Force Gradle to write to inherit the output directory from the parent, instead of writing to out/xxx/classes.
-    // This is required for Loom, and we patch Forge's run configurations to work there.
-    // TODO: Submit a patch to Forge to support ProjectRootManager.
-    inheritOutputDirs = true
-}

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

@@ -1,25 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-import cc.tweaked.gradle.CCTweakedPlugin
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
-plugins {
-    kotlin("jvm")
-}
-
-kotlin {
-    jvmToolchain {
-        languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
-    }
-}
-
-tasks.withType(KotlinCompile::class.java).configureEach {
-    // So technically we shouldn't need to do this as the toolchain sets it above. However, the option only appears
-    // to be set when the task executes, so doesn't get picked up by IDEs.
-    kotlinOptions.jvmTarget = when {
-        CCTweakedPlugin.JAVA_VERSION.asInt() > 8 -> CCTweakedPlugin.JAVA_VERSION.toString()
-        else -> "1.${CCTweakedPlugin.JAVA_VERSION.asInt()}"
-    }
-}

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

@@ -1,58 +0,0 @@
-// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-import net.darkhax.curseforgegradle.TaskPublishCurseForge
-import cc.tweaked.gradle.setProvider
-
-plugins {
-    id("net.darkhax.curseforgegradle")
-    id("com.modrinth.minotaur")
-    id("cc-tweaked.publishing")
-}
-
-abstract class ModPublishingExtension {
-    abstract val output: Property<AbstractArchiveTask>
-
-    init {
-        output.finalizeValueOnRead()
-    }
-}
-
-val modPublishing = project.extensions.create("modPublishing", ModPublishingExtension::class.java)
-
-val isUnstable = project.properties["isUnstable"] == "true"
-val modVersion: String by extra
-val mcVersion: String by extra
-
-val publishCurseForge by tasks.registering(TaskPublishCurseForge::class) {
-    group = PublishingPlugin.PUBLISH_TASK_GROUP
-    description = "Upload artifacts to CurseForge"
-
-    apiToken = findProperty("curseForgeApiKey") ?: ""
-    enabled = apiToken != ""
-
-    val mainFile = upload("282001", modPublishing.output)
-    mainFile.changelog =
-        "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion)."
-    mainFile.changelogType = "markdown"
-    mainFile.releaseType = if (isUnstable) "alpha" else "release"
-    mainFile.gameVersions.add(mcVersion)
-}
-
-tasks.publish { dependsOn(publishCurseForge) }
-
-modrinth {
-    token.set(findProperty("modrinthApiKey") as String? ?: "")
-    projectId.set("gu7yAYhd")
-    versionNumber.set(modVersion)
-    versionName.set(modVersion)
-    versionType.set(if (isUnstable) "alpha" else "release")
-    uploadFile.setProvider(modPublishing.output)
-    gameVersions.add(mcVersion)
-    changelog.set("Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion).")
-
-    syncBodyFrom.set(provider { rootProject.file("doc/mod-page.md").readText() })
-}
-
-tasks.publish { dependsOn(tasks.modrinth) }

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

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

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

@@ -1,41 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-/** Default configuration for non-modloader-specific Minecraft projects. */
-
-import cc.tweaked.gradle.CCTweakedExtension
-import cc.tweaked.gradle.CCTweakedPlugin
-import cc.tweaked.gradle.MinecraftConfigurations
-
-plugins {
-    id("cc-tweaked.java-convention")
-    id("cc.tweaked.vanilla-extract")
-}
-
-plugins.apply(CCTweakedPlugin::class.java)
-
-val mcVersion: String by extra
-
-val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-
-minecraft {
-    version(mcVersion)
-
-    mappings {
-        parchment(libs.findVersion("parchmentMc").get().toString(), libs.findVersion("parchment").get().toString())
-    }
-
-    unpick(libs.findLibrary("yarn").get())
-}
-
-dependencies {
-    // Depend on error prone annotations to silence a lot of compile warnings.
-    compileOnly(libs.findLibrary("errorProne.annotations").get())
-}
-
-MinecraftConfigurations.setupBasic(project)
-
-extensions.configure(CCTweakedExtension::class.java) {
-    linters(minecraft = true, loader = null)
-}

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

@@ -1,294 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import net.ltgt.gradle.errorprone.CheckSeverity
-import net.ltgt.gradle.errorprone.errorprone
-import org.gradle.api.GradleException
-import org.gradle.api.NamedDomainObjectProvider
-import org.gradle.api.Project
-import org.gradle.api.Task
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.attributes.TestSuiteType
-import org.gradle.api.file.FileSystemOperations
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.provider.ListProperty
-import org.gradle.api.provider.Provider
-import org.gradle.api.provider.SetProperty
-import org.gradle.api.reporting.ReportingExtension
-import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.compile.JavaCompile
-import org.gradle.api.tasks.javadoc.Javadoc
-import org.gradle.configurationcache.extensions.capitalized
-import org.gradle.language.base.plugins.LifecycleBasePlugin
-import org.gradle.language.jvm.tasks.ProcessResources
-import org.gradle.process.JavaForkOptions
-import org.gradle.testing.jacoco.plugins.JacocoCoverageReport
-import org.gradle.testing.jacoco.plugins.JacocoPluginExtension
-import org.gradle.testing.jacoco.plugins.JacocoTaskExtension
-import org.gradle.testing.jacoco.tasks.JacocoReport
-import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.io.File
-import java.io.IOException
-import java.net.URI
-import java.net.URL
-import java.util.regex.Pattern
-
-abstract class CCTweakedExtension(
-    private val project: Project,
-    private val fs: FileSystemOperations,
-) {
-    /** Get the hash of the latest git commit. */
-    val gitHash: Provider<String> = gitProvider(project, "<no git hash>") {
-        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "HEAD").trim()
-    }
-
-    /** Get the current git branch. */
-    val gitBranch: Provider<String> = gitProvider(project, "<no git branch>") {
-        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "--abbrev-ref", "HEAD")
-            .trim()
-    }
-
-    /** Get a list of all contributors to the project. */
-    val gitContributors: Provider<List<String>> = gitProvider(project, listOf()) {
-        ProcessHelpers.captureLines(
-            "git", "-C", project.rootProject.projectDir.absolutePath, "shortlog", "-ns",
-            "--group=author", "--group=trailer:co-authored-by", "HEAD",
-        )
-            .asSequence()
-            .map {
-                val matcher = COMMIT_COUNTS.matcher(it)
-                matcher.find()
-                matcher.group(1)
-            }
-            .filter { !IGNORED_USERS.contains(it) }
-            .toList()
-            .sortedWith(String.CASE_INSENSITIVE_ORDER)
-    }
-
-    /**
-     * References to other sources
-     */
-    val sourceDirectories: SetProperty<SourceSetReference> = project.objects.setProperty(SourceSetReference::class.java)
-
-    /**
-     * Dependencies excluded from published artifacts.
-     */
-    private val excludedDeps: ListProperty<Dependency> = project.objects.listProperty(Dependency::class.java)
-
-    /** All source sets referenced by this project. */
-    val sourceSets = sourceDirectories.map { x -> x.map { it.sourceSet } }
-
-    init {
-        sourceDirectories.finalizeValueOnRead()
-        excludedDeps.finalizeValueOnRead()
-        project.afterEvaluate { sourceDirectories.disallowChanges() }
-    }
-
-    /**
-     * Mark this project as consuming another project. Its [sourceDirectories] are added, allowing easier configuration
-     * of run configurations and other tasks which consume sources/classes.
-     */
-    fun externalSources(project: Project) {
-        val otherCct = project.extensions.getByType(CCTweakedExtension::class.java)
-        for (sourceSet in otherCct.sourceDirectories.get()) {
-            sourceDirectories.add(SourceSetReference(sourceSet.sourceSet, classes = sourceSet.classes, external = true))
-        }
-    }
-
-    /**
-     * Add a dependency on another project such that its sources and compiles are processed with this one.
-     *
-     * This is used when importing a common library into a loader-specific one, as we want to compile sources using
-     * the loader-specific sources.
-     */
-    fun inlineProject(path: String) {
-        val otherProject = project.evaluationDependsOn(path)
-        val otherJava = otherProject.extensions.getByType(JavaPluginExtension::class.java)
-        val main = otherJava.sourceSets.getByName("main")
-        val client = otherJava.sourceSets.getByName("client")
-        val testMod = otherJava.sourceSets.findByName("testMod")
-        val testFixtures = otherJava.sourceSets.findByName("testFixtures")
-
-        // Pull in sources from the other project.
-        extendSourceSet(otherProject, main)
-        extendSourceSet(otherProject, client)
-        if (testMod != null) extendSourceSet(otherProject, testMod)
-        if (testFixtures != null) extendSourceSet(otherProject, testFixtures)
-
-        // The extra source-processing tasks should include these files too.
-        project.tasks.named(main.javadocTaskName, Javadoc::class.java) { source(main.allJava, client.allJava) }
-        project.tasks.named(main.sourcesJarTaskName, Jar::class.java) { from(main.allSource, client.allSource) }
-        sourceDirectories.addAll(SourceSetReference.inline(main), SourceSetReference.inline(client))
-    }
-
-    /**
-     * Extend a source set with files from another project.
-     *
-     * This actually extends the original compile tasks, as extending the source sets does not play well with IDEs.
-     */
-    private fun extendSourceSet(otherProject: Project, sourceSet: SourceSet) {
-        project.tasks.named(sourceSet.compileJavaTaskName, JavaCompile::class.java) {
-            dependsOn(otherProject.tasks.named(sourceSet.compileJavaTaskName)) // Avoid duplicate compile errors
-            source(sourceSet.allJava)
-        }
-
-        project.tasks.named(sourceSet.processResourcesTaskName, ProcessResources::class.java) {
-            from(sourceSet.resources)
-        }
-
-        // Also try to depend on Kotlin if it exists
-        val kotlin = otherProject.extensions.findByType(KotlinProjectExtension::class.java)
-        if (kotlin != null) {
-            val compileKotlin = sourceSet.getCompileTaskName("kotlin")
-            project.tasks.named(compileKotlin, KotlinCompile::class.java) {
-                dependsOn(otherProject.tasks.named(compileKotlin))
-                source(kotlin.sourceSets.getByName(sourceSet.name).kotlin)
-            }
-        }
-
-        // If we're doing an IDE sync, add a fake dependency to ensure it's on the classpath.
-        if (isIdeSync) project.dependencies.add(sourceSet.apiConfigurationName, sourceSet.output)
-    }
-
-    fun linters(@Suppress("UNUSED_PARAMETER") vararg unused: UseNamedArgs, minecraft: Boolean, loader: String?) {
-        val java = project.extensions.getByType(JavaPluginExtension::class.java)
-        val sourceSets = java.sourceSets
-
-        project.dependencies.run { add("errorprone", project(mapOf("path" to ":lints"))) }
-        sourceSets.all {
-            val name = name
-            project.tasks.named(compileJavaTaskName, JavaCompile::class.java) {
-                options.errorprone {
-                    // Only the main source set should run the side checker
-                    check("SideChecker", if (minecraft && name == "main") CheckSeverity.DEFAULT else CheckSeverity.OFF)
-
-                    // The MissingLoaderOverride check superseeds the MissingOverride one, so disable that.
-                    if (loader != null) {
-                        check("MissingOverride", CheckSeverity.OFF)
-                        option("ModLoader", loader)
-                    } else {
-                        check("LoaderOverride", CheckSeverity.OFF)
-                        check("MissingLoaderOverride", CheckSeverity.OFF)
-                    }
-                }
-            }
-        }
-    }
-
-    fun <T> jacoco(task: NamedDomainObjectProvider<T>) where T : Task, T : JavaForkOptions {
-        val classDump = project.layout.buildDirectory.dir("jacocoClassDump/${task.name}")
-        val reportTaskName = "jacoco${task.name.capitalized()}Report"
-
-        val jacoco = project.extensions.getByType(JacocoPluginExtension::class.java)
-        task.configure {
-            finalizedBy(reportTaskName)
-
-            doFirst("Clean class dump directory") { fs.delete { delete(classDump) } }
-
-            jacoco.applyTo(this)
-            extensions.configure(JacocoTaskExtension::class.java) {
-                includes = listOf("dan200.computercraft.*")
-                classDumpDir = classDump.get().asFile
-
-                // Older versions of modlauncher don't include a protection domain (and thus no code
-                // source). Jacoco skips such classes by default, so we need to explicitly include them.
-                isIncludeNoLocationClasses = true
-            }
-        }
-
-        project.tasks.register(reportTaskName, JacocoReport::class.java) {
-            group = LifecycleBasePlugin.VERIFICATION_GROUP
-            description = "Generates code coverage report for the ${task.name} task."
-
-            executionData(task.get())
-            classDirectories.from(classDump)
-
-            // Don't want to use sourceSets(...) here as we have a custom class directory.
-            for (ref in sourceSets.get()) sourceDirectories.from(ref.allSource.sourceDirectories)
-        }
-
-        project.extensions.configure(ReportingExtension::class.java) {
-            reports.register("${task.name}CodeCoverageReport", JacocoCoverageReport::class.java) {
-                testType.set(TestSuiteType.INTEGRATION_TEST)
-            }
-        }
-    }
-
-    /**
-     * Download a file by creating a dummy Ivy repository.
-     *
-     * This should only be used for one-off downloads. Using a more conventional Ivy or Maven repository is preferred
-     * where possible.
-     */
-    fun downloadFile(label: String, url: String): File {
-        val url = URL(url)
-        val path = File(url.path)
-
-        project.repositories.ivy {
-            name = label
-            setUrl(URI(url.protocol, url.userInfo, url.host, url.port, path.parent, null, null))
-            patternLayout {
-                artifact("[artifact].[ext]")
-            }
-            metadataSources {
-                artifact()
-            }
-            content {
-                includeModule("cc.tweaked.internal", path.nameWithoutExtension)
-            }
-        }
-
-        return project.configurations.detachedConfiguration(
-            project.dependencies.create(
-                mapOf(
-                    "group" to "cc.tweaked.internal",
-                    "name" to path.nameWithoutExtension,
-                    "ext" to path.extension,
-                ),
-            ),
-        ).resolve().single()
-    }
-
-    /**
-     * Exclude a dependency from being published in Maven.
-     */
-    fun exclude(dep: Dependency) {
-        excludedDeps.add(dep)
-    }
-
-    /**
-     * Configure a [MavenDependencySpec].
-     */
-    fun configureExcludes(spec: MavenDependencySpec) {
-        for (dep in excludedDeps.get()) spec.exclude(dep)
-    }
-
-    companion object {
-        private val COMMIT_COUNTS = Pattern.compile("""^\s*[0-9]+\s+(.*)$""")
-        private val IGNORED_USERS = setOf(
-            "GitHub", "Daniel Ratcliffe", "Weblate",
-        )
-
-        private fun <T> gitProvider(project: Project, default: T, supplier: () -> T): Provider<T> {
-            return project.provider {
-                try {
-                    supplier()
-                } catch (e: IOException) {
-                    project.logger.error("Cannot read Git repository: ${e.message}")
-                    default
-                } catch (e: GradleException) {
-                    project.logger.error("Cannot read Git repository: ${e.message}")
-                    default
-                }
-            }
-        }
-
-        private val isIdeSync: Boolean
-            get() = java.lang.Boolean.parseBoolean(System.getProperty("idea.sync.active", "false"))
-    }
-}

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

@@ -1,47 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.jvm.toolchain.JavaLanguageVersion
-import org.gradle.plugins.ide.idea.model.IdeaModel
-import org.jetbrains.gradle.ext.IdeaExtPlugin
-import org.jetbrains.gradle.ext.runConfigurations
-import org.jetbrains.gradle.ext.settings
-
-/**
- * Configures projects to match a shared configuration.
- */
-class CCTweakedPlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        val cct = project.extensions.create("cct", CCTweakedExtension::class.java)
-
-        project.plugins.withType(JavaPlugin::class.java) {
-            val sourceSets = project.extensions.getByType(JavaPluginExtension::class.java).sourceSets
-            cct.sourceDirectories.add(SourceSetReference.internal(sourceSets.getByName("main")))
-        }
-
-        project.plugins.withType(IdeaExtPlugin::class.java) { extendIdea(project) }
-    }
-
-    /**
-     * Extend the [IdeaExtPlugin] plugin's `runConfiguration` container to also support [JUnitExt].
-     */
-    private fun extendIdea(project: Project) {
-        val ideaModel = project.extensions.findByName("idea") as IdeaModel? ?: return
-        val ideaProject = ideaModel.project ?: return
-
-        ideaProject.settings.runConfigurations {
-            registerFactory(JUnitExt::class.java) { name -> project.objects.newInstance(JUnitExt::class.java, name) }
-        }
-    }
-
-    companion object {
-        val JAVA_VERSION = JavaLanguageVersion.of(17)
-    }
-}

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

@@ -1,68 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.DefaultTask
-import org.gradle.api.GradleException
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.*
-import org.gradle.language.base.plugins.LifecycleBasePlugin
-
-/**
- * Checks the `changelog.md` and `whatsnew.md` files are well-formed.
- */
-@CacheableTask
-abstract class CheckChangelog : DefaultTask() {
-    init {
-        group = LifecycleBasePlugin.VERIFICATION_GROUP
-        description = "Verifies the changelog and whatsnew file are consistent."
-    }
-
-    @get:Input
-    abstract val version: Property<String>
-
-    @get:InputFile
-    @get:PathSensitive(PathSensitivity.NONE)
-    abstract val changelog: RegularFileProperty
-
-    @get:InputFile
-    @get:PathSensitive(PathSensitivity.NONE)
-    abstract val whatsNew: RegularFileProperty
-
-    @TaskAction
-    fun check() {
-        val version = version.get()
-
-        var ok = true
-
-        // Check we're targeting the current version
-        var whatsNew = whatsNew.get().asFile.readLines()
-        if (whatsNew[0] != "New features in CC: Tweaked $version") {
-            ok = false
-            logger.error("Expected `whatsnew.md' to target $version.")
-        }
-
-        // Check "read more" exists and trim it
-        val idx = whatsNew.indexOfFirst { it == "Type \"help changelog\" to see the full version history." }
-        if (idx == -1) {
-            ok = false
-            logger.error("Must mention the changelog in whatsnew.md")
-        } else {
-            whatsNew = whatsNew.slice(0 until idx)
-        }
-
-        // Check whatsnew and changelog match.
-        val expectedChangelog = sequenceOf("# ${whatsNew[0]}") + whatsNew.slice(1 until whatsNew.size).asSequence()
-        val changelog = changelog.get().asFile.readLines()
-        val mismatch = expectedChangelog.zip(changelog.asSequence()).filter { (a, b) -> a != b }.firstOrNull()
-        if (mismatch != null) {
-            ok = false
-            logger.error("whatsnew and changelog are not in sync")
-        }
-
-        if (!ok) throw GradleException("Could not check release")
-    }
-}

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

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

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

@@ -1,16 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.AbstractExecTask
-import org.gradle.api.tasks.OutputDirectory
-import java.io.File
-
-abstract class ExecToDir : AbstractExecTask<ExecToDir>(ExecToDir::class.java) {
-    @get:OutputDirectory
-    abstract val output: DirectoryProperty
-}

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

@@ -1,157 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.artifacts.dsl.DependencyHandler
-import org.gradle.api.file.FileSystemLocation
-import org.gradle.api.provider.Property
-import org.gradle.api.provider.Provider
-import org.gradle.api.tasks.JavaExec
-import org.gradle.process.BaseExecSpec
-import org.gradle.process.JavaExecSpec
-import org.gradle.process.ProcessForkOptions
-
-/**
- * Add an annotation processor to all source sets.
- */
-fun DependencyHandler.annotationProcessorEverywhere(dep: Any) {
-    add("compileOnly", dep)
-    add("annotationProcessor", dep)
-
-    add("clientCompileOnly", dep)
-    add("clientAnnotationProcessor", dep)
-
-    add("testCompileOnly", dep)
-    add("testAnnotationProcessor", dep)
-}
-
-/**
- * A version of [JavaExecSpec.copyTo] which copies *all* properties.
- */
-fun JavaExec.copyToFull(spec: JavaExec) {
-    copyTo(spec)
-
-    // Additional Java options
-    spec.jvmArgs = jvmArgs // Fabric overrides getJvmArgs so copyTo doesn't do the right thing.
-    spec.args = args
-    spec.argumentProviders.addAll(argumentProviders)
-    spec.mainClass.set(mainClass)
-    spec.classpath = classpath
-    spec.javaLauncher.set(javaLauncher)
-    if (executable != null) spec.setExecutable(executable!!)
-
-    // Additional ExecSpec options
-    copyToExec(spec)
-}
-
-/**
- * Copy additional [BaseExecSpec] options which aren't handled by [ProcessForkOptions.copyTo].
- */
-fun BaseExecSpec.copyToExec(spec: BaseExecSpec) {
-    spec.isIgnoreExitValue = isIgnoreExitValue
-    if (standardInput != null) spec.standardInput = standardInput
-    if (standardOutput != null) spec.standardOutput = standardOutput
-    if (errorOutput != null) spec.errorOutput = errorOutput
-}
-
-/**
- * An alternative to [Nothing] with a more descriptive name. Use to enforce calling a function with named arguments:
- *
- * ```kotlin
- * fun f(vararg unused: UseNamedArgs, arg1: Int, arg2: Int) {
- *   // ...
- * }
- * ```
- */
-class UseNamedArgs private constructor()
-
-/**
- * An [AutoCloseable] implementation which can be used to combine other [AutoCloseable] instances.
- *
- * Values which implement [AutoCloseable] can be dynamically registered with [CloseScope.add]. When the scope is closed,
- * each value is closed in the opposite order.
- *
- * This is largely intended for cases where it's not appropriate to nest [AutoCloseable.use], for instance when nested
- * would be too deep.
- */
-class CloseScope : AutoCloseable {
-    private val toClose = ArrayDeque<AutoCloseable>()
-
-    /**
-     * Add a value to be closed when this scope is closed.
-     */
-    public fun add(value: AutoCloseable) {
-        toClose.addLast(value)
-    }
-
-    override fun close() {
-        close(null)
-    }
-
-    @PublishedApi
-    internal fun close(baseException: Throwable?) {
-        var exception = baseException
-
-        while (true) {
-            var toClose = toClose.removeLastOrNull() ?: break
-            try {
-                toClose.close()
-            } catch (e: Throwable) {
-                if (exception == null) {
-                    exception = e
-                } else {
-                    exception.addSuppressed(e)
-                }
-            }
-        }
-
-        if (exception != null) throw exception
-    }
-
-    inline fun <R> use(block: (CloseScope) -> R): R {
-        var exception: Throwable? = null
-        try {
-            return block(this)
-        } catch (e: Throwable) {
-            exception = e
-            throw e
-        } finally {
-            close(exception)
-        }
-    }
-}
-
-/** Proxy method to avoid overload ambiguity. */
-fun <T> Property<T>.setProvider(provider: Provider<out T>) = set(provider)
-
-/** Short-cut method to get the absolute path of a [FileSystemLocation] provider. */
-fun Provider<out FileSystemLocation>.getAbsolutePath(): String = get().asFile.absolutePath
-
-/**
- * Get the version immediately after the provided version.
- *
- * For example, given "1.2.3", this will return "1.2.4".
- */
-fun getNextVersion(version: String): String {
-    // Split a version like x.y.z-SNAPSHOT into x.y.z and -SNAPSHOT
-    val dashIndex = version.indexOf('-')
-    val mainVersion = if (dashIndex < 0) version else version.substring(0, dashIndex)
-
-    // Find the last component in x.y.z and increment it.
-    val lastIndex = mainVersion.lastIndexOf('.')
-    if (lastIndex < 0) throw IllegalArgumentException("Cannot parse version format \"$version\"")
-    val lastVersion = try {
-        version.substring(lastIndex + 1).toInt()
-    } catch (e: NumberFormatException) {
-        throw IllegalArgumentException("Cannot parse version format \"$version\"", e)
-    }
-
-    // Then append all components together.
-    val out = StringBuilder()
-    out.append(version, 0, lastIndex + 1)
-    out.append(lastVersion + 1)
-    if (dashIndex >= 0) out.append(version, dashIndex, version.length)
-    return out.toString()
-}

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

@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import net.minecraftforge.gradle.common.util.RunConfig
-import net.minecraftforge.gradle.common.util.runs.setRunConfigInternal
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.tasks.JavaExec
-import org.gradle.jvm.toolchain.JavaToolchainService
-import java.nio.file.Files
-
-/**
- * Set [JavaExec] task to run a given [RunConfig].
- */
-fun JavaExec.setRunConfig(config: RunConfig) {
-    dependsOn("prepareRuns")
-    setRunConfigInternal(project, this, config)
-    doFirst("Create working directory") { Files.createDirectories(workingDir.toPath()) }
-
-    javaLauncher.set(
-        project.extensions.getByType(JavaToolchainService::class.java)
-            .launcherFor(project.extensions.getByType(JavaPluginExtension::class.java).toolchain),
-    )
-}

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

@@ -1,23 +0,0 @@
-// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.jetbrains.gradle.ext.JUnit
-import javax.inject.Inject
-
-/**
- * A version of [JUnit] with a functional [className].
- *
- * See [#92](https://github.com/JetBrains/gradle-idea-ext-plugin/issues/92).
- */
-open class JUnitExt @Inject constructor(nameParam: String) : JUnit(nameParam) {
-    override fun toMap(): MutableMap<String, *> {
-        val map = HashMap(super.toMap())
-        // Should be "class" instead of "className".
-        // See https://github.com/JetBrains/intellij-community/blob/9ba394021dc73a3926f13d6d6cdf434f9ee7046d/plugins/junit/src/com/intellij/execution/junit/JUnitRunConfigurationImporter.kt#L39
-        map["class"] = className
-        return map
-    }
-}

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

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

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

@@ -1,127 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.DefaultTask
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.Task
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.provider.Property
-import org.gradle.api.provider.Provider
-import org.gradle.api.tasks.AbstractExecTask
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.TaskAction
-import java.io.File
-
-abstract class IlluaminateExtension {
-    /** The version of illuaminate to use. */
-    abstract val version: Property<String>
-
-    /** The path to illuaminate. If not given, illuaminate will be downloaded automatically. */
-    abstract val file: Property<File>
-}
-
-class IlluaminatePlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        val extension = project.extensions.create("illuaminate", IlluaminateExtension::class.java)
-        extension.file.convention(setupDependency(project, extension.version))
-
-        project.tasks.register(SetupIlluaminate.NAME, SetupIlluaminate::class.java) {
-            file.set(extension.file.map { it.absolutePath })
-        }
-    }
-
-    /** Set up a repository for illuaminate and download our binary from it. */
-    private fun setupDependency(project: Project, version: Provider<String>): Provider<File> {
-        project.repositories.ivy {
-            name = "Illuaminate"
-            setUrl("https://squiddev.cc/illuaminate/bin/")
-            patternLayout {
-                artifact("[revision]/[artifact]-[ext]")
-            }
-            metadataSources {
-                artifact()
-            }
-            content {
-                includeModule("cc.squiddev", "illuaminate")
-            }
-        }
-
-        return version.map {
-            val dep = illuaminateArtifact(project, it)
-            val configuration = project.configurations.detachedConfiguration(dep)
-            configuration.isTransitive = false
-            configuration.resolve().single()
-        }
-    }
-
-    /** Define a dependency for illuaminate from a version number and the current operating system. */
-    private fun illuaminateArtifact(project: Project, version: String): Dependency {
-        val osName = System.getProperty("os.name").lowercase()
-        val (os, suffix) = when {
-            osName.contains("windows") -> Pair("windows", ".exe")
-            osName.contains("mac os") || osName.contains("darwin") -> Pair("macos", "")
-            osName.contains("linux") -> Pair("linux", "")
-            else -> error("Unsupported OS $osName for illuaminate")
-        }
-
-        val osArch = System.getProperty("os.arch").lowercase()
-        val arch = when {
-            // On macOS the x86_64 binary will work for both ARM and Intel Macs through Rosetta.
-            os == "macos" -> "x86_64"
-            osArch == "arm" || osArch.startsWith("aarch") -> error("Unsupported architecture '$osArch' for illuaminate")
-            osArch.contains("64") -> "x86_64"
-            else -> error("Unsupported architecture '$osArch' for illuaminate")
-        }
-
-        return project.dependencies.create(
-            mapOf(
-                "group" to "cc.squiddev",
-                "name" to "illuaminate",
-                "version" to version,
-                "ext" to "$os-$arch$suffix",
-            ),
-        )
-    }
-}
-
-private val Task.illuaminatePath: String? // "?" needed to avoid overload ambiguity in setExecutable below.
-    get() = project.extensions.getByType(IlluaminateExtension::class.java).file.get().absolutePath
-
-/** Prepares illuaminate for being run. This simply requests the dependency and then marks it as executable. */
-abstract class SetupIlluaminate : DefaultTask() {
-    @get:Input
-    abstract val file: Property<String>
-
-    @TaskAction
-    fun setExecutable() {
-        val file = File(this.file.get())
-        if (file.canExecute()) {
-            didWork = false
-            return
-        }
-
-        file.setExecutable(true)
-    }
-
-    companion object {
-        const val NAME: String = "setupIlluaminate"
-    }
-}
-
-abstract class IlluaminateExec : AbstractExecTask<IlluaminateExec>(IlluaminateExec::class.java) {
-    init {
-        dependsOn(SetupIlluaminate.NAME)
-        executable = illuaminatePath
-    }
-}
-
-abstract class IlluaminateExecToDir : ExecToDir() {
-    init {
-        dependsOn(SetupIlluaminate.NAME)
-        executable = illuaminatePath
-    }
-}

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

@@ -1,73 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.artifacts.MinimalExternalModuleDependency
-import org.gradle.api.artifacts.ProjectDependency
-import org.gradle.api.plugins.BasePluginExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.specs.Spec
-
-/**
- * A dependency in a POM file.
- */
-data class MavenDependency(val groupId: String?, val artifactId: String?, val version: String?, val scope: String?)
-
-/**
- * A spec specifying which dependencies to include/exclude.
- */
-class MavenDependencySpec {
-    private val excludeSpecs = mutableListOf<Spec<MavenDependency>>()
-
-    fun exclude(spec: Spec<MavenDependency>) {
-        excludeSpecs.add(spec)
-    }
-
-    fun exclude(dep: Dependency) {
-        exclude {
-            // We have to cheat a little for project dependencies, as the project name doesn't match the artifact group.
-            val name = when (dep) {
-                is ProjectDependency -> dep.dependencyProject.extensions.getByType(BasePluginExtension::class.java).archivesName.get()
-                else -> dep.name
-            }
-            (dep.group.isNullOrEmpty() || dep.group == it.groupId) &&
-                (name.isNullOrEmpty() || name == it.artifactId) &&
-                (dep.version.isNullOrEmpty() || dep.version == it.version)
-        }
-    }
-
-    fun exclude(dep: MinimalExternalModuleDependency) {
-        exclude {
-            dep.module.group == it.groupId && dep.module.name == it.artifactId
-        }
-    }
-
-    fun isIncluded(dep: MavenDependency) = !excludeSpecs.any { it.isSatisfiedBy(dep) }
-}
-
-/**
- * Configure dependencies present in this publication's POM file.
- *
- * While this approach is very ugly, it's the easiest way to handle it!
- */
-fun MavenPublication.mavenDependencies(action: MavenDependencySpec.() -> Unit) {
-    val spec = MavenDependencySpec()
-    action(spec)
-
-    pom.withXml {
-        val dependencies = XmlUtil.findChild(asNode(), "dependencies") ?: return@withXml
-        dependencies.children().map { it as groovy.util.Node }.forEach {
-            val dep = MavenDependency(
-                groupId = XmlUtil.findChild(it, "groupId")?.text(),
-                artifactId = XmlUtil.findChild(it, "artifactId")?.text(),
-                version = XmlUtil.findChild(it, "version")?.text(),
-                scope = XmlUtil.findChild(it, "scope")?.text(),
-            )
-
-            if (!spec.isIncluded(dep)) it.parent().remove(it)
-        }
-    }
-}

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

@@ -1,120 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import cc.tweaked.vanillaextract.configurations.Capabilities
-import cc.tweaked.vanillaextract.configurations.MinecraftSetup
-import org.gradle.api.Project
-import org.gradle.api.artifacts.ModuleDependency
-import org.gradle.api.artifacts.dsl.DependencyHandler
-import org.gradle.api.plugins.BasePlugin
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.javadoc.Javadoc
-import org.gradle.kotlin.dsl.get
-
-/**
- * This sets up a separate client-only source set, and extends that and the main/common source set with additional
- * metadata, to make it easier to consume jars downstream.
- */
-class MinecraftConfigurations private constructor(private val project: Project) {
-    private val java = project.extensions.getByType(JavaPluginExtension::class.java)
-    private val sourceSets = java.sourceSets
-    private val configurations = project.configurations
-    private val objects = project.objects
-
-    private val main = sourceSets[SourceSet.MAIN_SOURCE_SET_NAME]
-    private val test = sourceSets[SourceSet.TEST_SOURCE_SET_NAME]
-
-    /**
-     * Performs the initial setup of our configurations.
-     */
-    private fun setup() {
-        // Define a client source set.
-        val client = sourceSets.maybeCreate("client")
-
-        // Ensure the client classpaths behave the same as the main ones.
-        configurations.named(client.compileClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
-        }
-
-        configurations.named(client.runtimeClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
-        }
-
-        // Set up an API configuration for clients (to ensure it's consistent with the main source set).
-        val clientApi = configurations.maybeCreate(client.apiConfigurationName).apply {
-            isVisible = false
-            isCanBeConsumed = false
-            isCanBeResolved = false
-        }
-        configurations.named(client.implementationConfigurationName) { extendsFrom(clientApi) }
-
-        project.tasks.register(client.jarTaskName, Jar::class.java) {
-            description = "An empty jar standing in for the client classes."
-            group = BasePlugin.BUILD_GROUP
-            archiveClassifier.set("client")
-        }
-
-        MinecraftSetup(project).setupOutgoingConfigurations()
-
-        // Reset the client classpath (Loom configures it slightly differently to this) and add a main -> client
-        // dependency. Here we /can/ use source set outputs as we add transitive deps by patching the classpath. Nasty,
-        // but avoids accidentally pulling in Forge's obfuscated jar.
-        client.compileClasspath = client.compileClasspath + main.compileClasspath
-        client.runtimeClasspath = client.runtimeClasspath + main.runtimeClasspath
-        project.dependencies.add(client.apiConfigurationName, main.output)
-
-        // Also add client classes to the test classpath. We do the same nasty tricks as needed for main -> client.
-        test.compileClasspath += client.compileClasspath
-        test.runtimeClasspath += client.runtimeClasspath
-        project.dependencies.add(test.implementationConfigurationName, client.output)
-
-        // Configure some tasks to include our additional files.
-        project.tasks.named("javadoc", Javadoc::class.java) {
-            source(client.allJava)
-            classpath = main.compileClasspath + main.output + client.compileClasspath + client.output
-        }
-        // This are already done by Fabric, but we need it for Forge and vanilla. It shouldn't conflict at all.
-        project.tasks.named("jar", Jar::class.java) { from(client.output) }
-        project.tasks.named("sourcesJar", Jar::class.java) { from(client.allSource) }
-
-        setupBasic()
-    }
-
-    private fun setupBasic() {
-        val client = sourceSets["client"]
-
-        project.extensions.configure(CCTweakedExtension::class.java) {
-            sourceDirectories.add(SourceSetReference.internal(client))
-        }
-
-        // Register a task to check there are no conflicts with the core project.
-        val checkDependencyConsistency =
-            project.tasks.register("checkDependencyConsistency", DependencyCheck::class.java) {
-                // We need to check both the main and client classpath *configurations*, as the actual configuration
-                configuration.add(configurations.named(main.runtimeClasspathConfigurationName))
-                configuration.add(configurations.named(client.runtimeClasspathConfigurationName))
-            }
-        project.tasks.named("check") { dependsOn(checkDependencyConsistency) }
-    }
-
-    companion object {
-        fun setupBasic(project: Project) {
-            MinecraftConfigurations(project).setupBasic()
-        }
-
-        fun setup(project: Project) {
-            MinecraftConfigurations(project).setup()
-        }
-    }
-}
-
-fun DependencyHandler.clientClasses(notation: Any): ModuleDependency =
-    Capabilities.clientClasses(create(notation) as ModuleDependency)
-
-fun DependencyHandler.commonClasses(notation: Any): ModuleDependency =
-    Capabilities.commonClasses(create(notation) as ModuleDependency)

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

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

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

@@ -1,64 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.DefaultTask
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.file.Directory
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.provider.Provider
-import org.gradle.api.tasks.*
-import java.io.File
-
-class NodePlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        val extension = project.extensions.create("node", NodeExtension::class.java)
-        project.tasks.register(NpmInstall.TASK_NAME, NpmInstall::class.java) {
-            projectRoot.convention(extension.projectRoot)
-        }
-    }
-}
-
-abstract class NodeExtension(project: Project) {
-    /** The directory containing `package-lock.json` and `node_modules/`. */
-    abstract val projectRoot: DirectoryProperty
-
-    init {
-        projectRoot.convention(project.layout.projectDirectory)
-    }
-}
-
-/** Installs node modules as dependencies. */
-abstract class NpmInstall : DefaultTask() {
-    @get:Internal
-    abstract val projectRoot: DirectoryProperty
-
-    @get:InputFile
-    @get:PathSensitive(PathSensitivity.NONE)
-    val packageLock: Provider<File> = projectRoot.file("package-lock.json").map { it.asFile }
-
-    @get:OutputDirectory
-    val nodeModules: Provider<Directory> = projectRoot.dir("node_modules")
-
-    @TaskAction
-    fun install() {
-        project.exec {
-            commandLine("npm", "ci")
-            workingDir = projectRoot.get().asFile
-        }
-    }
-
-    companion object {
-        internal const val TASK_NAME: String = "npmInstall"
-    }
-}
-
-abstract class NpxExecToDir : ExecToDir() {
-    init {
-        dependsOn(NpmInstall.TASK_NAME)
-        executable = "npx"
-    }
-}

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

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

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

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

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

@@ -1,16 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import groovy.util.Node
-import groovy.util.NodeList
-
-object XmlUtil {
-    fun findChild(node: Node, name: String): Node? = when (val child = node.get(name)) {
-        is Node -> child
-        is NodeList -> child.singleOrNull() as Node?
-        else -> null
-    }
-}

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

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

config/checkstyle/checkstyle.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
-
-<!--
-SPDX-FileCopyrightText: 2019 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 <!DOCTYPE module PUBLIC
     "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
     "https://checkstyle.org/dtds/configuration_1_3.dtd">
@@ -13,10 +6,6 @@ SPDX-License-Identifier: MPL-2.0
     <property name="tabWidth" value="4"/>
     <property name="charset" value="UTF-8" />
 
-    <module name="BeforeExecutionExclusionFileFilter">
-        <property name="fileNamePattern" value="module\-info\.java$"/>
-    </module>
-
     <module name="SuppressionFilter">
 	<property name="file" value="${config_loc}/suppressions.xml" />
     </module>
@@ -28,10 +17,7 @@ SPDX-License-Identifier: MPL-2.0
     <module name="TreeWalker">
         <!-- Annotations -->
         <module name="AnnotationLocation" />
-        <module name="AnnotationUseStyle">
+        <module name="AnnotationUseStyle" />
-            <!-- We want trailing commas on multiline arrays. -->
-            <property name="trailingArrayComma" value="ignore" />
-        </module>
         <module name="MissingDeprecated" />
         <module name="MissingOverride" />
 
@@ -40,11 +26,17 @@ SPDX-License-Identifier: MPL-2.0
         <module name="EmptyCatchBlock">
             <property name="exceptionVariableName" value="ignored" />
         </module>
-        <module name="LeftCurly" />
+        <module name="LeftCurly">
+            <property name="option" value="nl" />
+            <!-- The defaults, minus lambdas. -->
+            <property name="tokens" value="ANNOTATION_DEF,CLASS_DEF,CTOR_DEF,ENUM_CONSTANT_DEF,ENUM_DEF,INTERFACE_DEF,LITERAL_CASE,LITERAL_CATCH,LITERAL_DEFAULT,LITERAL_DO,LITERAL_ELSE,LITERAL_FINALLY,LITERAL_FOR,LITERAL_IF,LITERAL_SWITCH,LITERAL_SYNCHRONIZED,LITERAL_TRY,LITERAL_WHILE,METHOD_DEF,OBJBLOCK,STATIC_INIT" />
+        </module>
         <module name="NeedBraces">
             <property name="allowSingleLineStatement" value="true"/>
         </module>
-        <module name="RightCurly" />
+        <module name="RightCurly">
+            <property name="option" value="alone" />
+        </module>
 
         <!-- Class design. As if we've ever followed good practice here. -->
         <module name="FinalClass" />
@@ -66,36 +58,25 @@ SPDX-License-Identifier: MPL-2.0
         <module name="SimplifyBooleanExpression" />
         <module name="SimplifyBooleanReturn" />
         <module name="StringLiteralEquality" />
-        <module name="UnnecessaryParentheses">
+        <module name="UnnecessaryParentheses" />
-            <!-- Default minus LAND. -->
-            <property name="tokens" value="EXPR,IDENT,NUM_DOUBLE,NUM_FLOAT,NUM_INT,NUM_LONG,STRING_LITERAL,LITERAL_NULL,LITERAL_FALSE,LITERAL_TRUE,ASSIGN,BAND_ASSIGN,BOR_ASSIGN,BSR_ASSIGN,BXOR_ASSIGN,DIV_ASSIGN,MINUS_ASSIGN,MOD_ASSIGN,PLUS_ASSIGN,SL_ASSIGN,SR_ASSIGN,STAR_ASSIGN,LAMBDA,TEXT_BLOCK_LITERAL_BEGIN,LITERAL_INSTANCEOF,GT,LT,GE,LE,EQUAL,NOT_EQUAL,UNARY_MINUS,UNARY_PLUS,INC,DEC,LNOT,BNOT,POST_INC,POST_DEC" />
-        </module>
         <module name="UnnecessarySemicolonAfterTypeMemberDeclaration" />
         <module name="UnnecessarySemicolonInTryWithResources" />
         <module name="UnnecessarySemicolonInEnumeration" />
 
         <!-- Imports -->
-        <module name="CustomImportOrder">
+        <module name="CustomImportOrder" />
-            <property name="customImportOrderRules"
-                value="THIRD_PARTY_PACKAGE###STANDARD_JAVA_PACKAGE###STATIC"
-            />
-        </module>
         <module name="IllegalImport" />
         <module name="RedundantImport" />
         <module name="UnusedImports" />
 
         <!-- Javadoc -->
         <!-- TODO: Missing* checks for the dan200.computercraft.api package? -->
-        <module name="AtclauseOrder">
+        <module name="AtclauseOrder" />
-            <property name="tagOrder" value="@param, @return, @throws, @deprecated"/>
-        </module>
         <module name="InvalidJavadocPosition" />
         <module name="JavadocBlockTagLocation" />
         <module name="JavadocMethod"/>
         <module name="JavadocType"/>
-        <module name="JavadocStyle">
+        <module name="JavadocStyle" />
-            <property name="checkHtml" value="false" />
-        </module>
         <module name="NonEmptyAtclauseDescription" />
         <module name="SingleLineJavadoc" />
         <module name="SummaryJavadocCheck"/>
@@ -116,19 +97,20 @@ SPDX-License-Identifier: MPL-2.0
         <module name="LambdaParameterName" />
         <module name="LocalFinalVariableName" />
         <module name="LocalVariableName" />
-        <module name="MemberName">
+        <module name="MemberName" />
-            <property name="format" value="^\$?[a-z][a-zA-Z0-9]*$" />
+        <module name="MethodName" />
-        </module>
-        <module name="MethodName">
-            <property name="format" value="^(computercraft\$)?[a-z][a-zA-Z0-9]*$" />
-        </module>
         <module name="MethodTypeParameterName" />
         <module name="PackageName">
-            <property name="format" value="^(dan200\.computercraft|cc\.tweaked)(\.[a-z][a-z0-9]*)*" />
+            <property name="format" value="^dan200\.computercraft(\.[a-z][a-z0-9]*)*" />
         </module>
         <module name="ParameterName" />
         <module name="StaticVariableName">
-            <property name="format" value="^[a-z][a-zA-Z0-9]*$" />
+            <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" />
 
@@ -141,11 +123,18 @@ SPDX-License-Identifier: MPL-2.0
         <module name="MethodParamPad" />
         <module name="NoLineWrap" />
         <module name="NoWhitespaceAfter">
-            <property name="tokens" value="AT,INC,DEC,UNARY_MINUS,UNARY_PLUS,BNOT,LNOT,DOT,ARRAY_DECLARATOR,INDEX_OP,METHOD_REF" />
+            <property name="tokens" value="AT,INC,DEC,UNARY_MINUS,UNARY_PLUS,BNOT,LNOT,DOT,ARRAY_DECLARATOR,INDEX_OP" />
         </module>
         <module name="NoWhitespaceBefore" />
         <!-- TODO: Decide on an OperatorWrap style. -->
-        <module name="ParenPad" />
+        <module name="ParenPad">
+            <property name="option" value="space" />
+            <property name="tokens" value="ANNOTATION,ANNOTATION_FIELD_DEF,CTOR_CALL,CTOR_DEF,ENUM_CONSTANT_DEF,LITERAL_CATCH,LITERAL_DO,LITERAL_FOR,LITERAL_IF,LITERAL_NEW,LITERAL_SWITCH,LITERAL_SYNCHRONIZED,LITERAL_WHILE,METHOD_CALL,METHOD_DEF,RESOURCE_SPECIFICATION,SUPER_CTOR_CALL,LAMBDA" />
+        </module>
+        <module name="ParenPad">
+            <property name="option" value="nospace" />
+            <property name="tokens" value="DOT,EXPR,QUESTION" />
+        </module>
         <module name="SeparatorWrap">
             <property name="option" value="eol" />
             <property name="tokens" value="COMMA,SEMI,ELLIPSIS,ARRAY_DECLARATOR,RBRACK,METHOD_REF" />
@@ -160,13 +149,8 @@ SPDX-License-Identifier: MPL-2.0
             <property name="tokens" value="COMMA" />
         </module>
         <module name="WhitespaceAround">
-            <property name="ignoreEnhancedForColon" value="false" />
-            <!-- Allow empty functions -->
-            <property name="allowEmptyLambdas" value="true" />
-            <property name="allowEmptyMethods" value="true" />
             <property name="allowEmptyConstructors" value="true" />
-            <property name="allowEmptyTypes" 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,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>

config/checkstyle/suppressions.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
-
-<!--
-SPDX-FileCopyrightText: 2019 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 <!DOCTYPE suppressions PUBLIC
     "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
     "https://checkstyle.org/dtds/suppressions_1_2.dtd">
@@ -16,10 +9,4 @@ SPDX-License-Identifier: MPL-2.0
 
     <!-- The commands API is documented in Lua. -->
     <suppress checks="SummaryJavadocCheck" files=".*[\\/]CommandAPI.java" />
-
-    <!-- Allow putting files in other packages if they look like our TeaVM stubs. -->
-    <suppress checks="PackageName" files=".*[\\/]T[A-Za-z]+.java" />
-
-    <!-- Allow underscores in our test classes. -->
-    <suppress checks="MethodName" files=".*(Contract|Test).java" />
 </suppressions>

config/gitpod/Dockerfile

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

config/idea/codeStyleSettings.xml

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

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

config/pre-commit/config.yml

@@ -0,0 +1,55 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v3.2.0
+  hooks:
+  - id: trailing-whitespace
+  - id: end-of-file-fixer
+  - id: check-merge-conflict
+
+  # Quick syntax checkers
+  - id: check-xml
+  - id: check-yaml
+  - id: check-toml
+  - id: check-json
+    exclude: "tsconfig\\.json$"
+
+- repo: https://github.com/editorconfig-checker/editorconfig-checker.python
+  rev: 2.3.5
+  hooks:
+  - id: editorconfig-checker
+    args: ['-disable-indentation']
+    exclude: "^(.*\\.(bat)|LICENSE)$"
+
+- repo: local
+  hooks:
+  - id: checkstyle
+    name: Check Java codestyle
+    files: ".*\\.java$"
+    language: system
+    entry: ./gradlew checkstyleMain checkstyleTest
+    pass_filenames: false
+    require_serial: true
+  - id: license
+    name: Check Java license headers
+    files: ".*\\.java$"
+    language: system
+    entry: ./gradlew licenseFormat
+    pass_filenames: false
+    require_serial: true
+  - id: illuaminate
+    name: Check Lua code
+    files: ".*\\.(lua|java|md)"
+    language: script
+    entry: config/pre-commit/illuaminate-lint.sh
+    pass_filenames: false
+    require_serial: true
+
+exclude: |
+  (?x)^(
+    src/generated|
+    src/test/resources/test-rom/data/json-parsing/|
+    src/test/server-files/|
+    config/idea/
+  )

config/pre-commit/illuaminate-lint.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env sh
+set -e
+
+test -d bin || mkdir bin
+test -f bin/illuaminate || curl -s -obin/illuaminate https://squiddev.cc/illuaminate/linux-x86-64/illuaminate
+chmod +x bin/illuaminate
+
+if [ -n ${GITHUB_ACTIONS+x} ]; then
+    # Register a problem matcher (see https://github.com/actions/toolkit/blob/master/docs/problem-matchers.md)
+    # for illuaminate.
+    echo "::add-matcher::.github/matchers/illuaminate.json"
+    trap 'echo "::remove-matcher owner=illuaminate::"' EXIT
+fi
+
+./gradlew luaJavadoc
+bin/illuaminate lint

doc/events/alarm.md

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

doc/events/char.md

@@ -3,26 +3,19 @@ module: [kind=event] char
 see: key To listen to any key press.
 ---
 
-<!--
+The @{char} event is fired when a character is _typed_ on the keyboard.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+The @{char} event is different to a key press. Sometimes multiple key presses may result in one character being
--->
-
-The [`char`] event is fired when a character is typed on the keyboard.
-
-The [`char`] event is different to a key press. Sometimes multiple key presses may result in one character being
 typed (for instance, on some European keyboards). Similarly, some keys (e.g. <kbd>Ctrl</kbd>) do not have any
-corresponding character. The [`key`] should be used if you want to listen to key presses themselves.
+corresponding character. The @{key} should be used if you want to listen to key presses themselves.
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The string representing the character that was pressed.
+2. @{string}: The string representing the character that was pressed.
 
 
 ## Example
 Prints each character the user presses:
-
 ```lua
 while true do
   local event, character = os.pullEvent("char")

doc/events/computer_command.md

@@ -2,17 +2,11 @@
 module: [kind=event] computer_command
 ---
 
-<!--
+The @{computer_command} event is fired when the `/computercraft queue` command is run for the current computer.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`computer_command`] event is fired when the `/computercraft queue` command is run for the current computer.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]<abbr title="Variable number of arguments">&hellip;</abbr>: The arguments passed to the command.
+... @{string}: The arguments passed to the command.
 
 ## Example
 Prints the contents of messages sent:

doc/events/disk.md

@@ -3,17 +3,11 @@ module: [kind=event] disk
 see: disk_eject For the event sent when a disk is removed.
 ---
 
-<!--
+The @{disk} event is fired when a disk is inserted into an adjacent or networked disk drive.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`disk`] event is fired when a disk is inserted into an adjacent or networked disk drive.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The side of the disk drive that had a disk inserted.
+2. @{string}: The side of the disk drive that had a disk inserted.
 
 ## Example
 Prints a message when a disk is inserted:

doc/events/disk_eject.md

@@ -3,17 +3,11 @@ module: [kind=event] disk_eject
 see: disk For the event sent when a disk is inserted.
 ---
 
-<!--
+The @{disk_eject} event is fired when a disk is removed from an adjacent or networked disk drive.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`disk_eject`] event is fired when a disk is removed from an adjacent or networked disk drive.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The side of the disk drive that had a disk removed.
+2. @{string}: The side of the disk drive that had a disk removed.
 
 ## Example
 Prints a message when a disk is removed:

doc/events/file_transfer.md

@@ -1,48 +0,0 @@
----
-module: [kind=event] file_transfer
-since: 1.101.0
----
-
-<!--
-SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`file_transfer`] event is queued when a user drags-and-drops a file on an open computer.
-
-This event contains a single argument of type [`TransferredFiles`], which can be used to [get the files to be
-transferred][`TransferredFiles.getFiles`]. Each file returned is a [binary file handle][`fs.ReadHandle`] with an
-additional [getName][`TransferredFile.getName`] method.
-
-## Return values
-1. [`string`]: The event name
-2. [`TransferredFiles`]: The list of transferred files.
-
-## Example
-Waits for a user to drop files on top of the computer, then prints the list of files and the size of each file.
-
-```lua
-local _, files = os.pullEvent("file_transfer")
-for _, file in ipairs(files.getFiles()) do
-  -- Seek to the end of the file to get its size, then go back to the beginning.
-  local size = file.seek("end")
-  file.seek("set", 0)
-
-  print(file.getName() .. " " .. size)
-end
-```
-
-## Example
-Save each transferred file to the computer's storage.
-
-```lua
-local _, files = os.pullEvent("file_transfer")
-for _, file in ipairs(files.getFiles()) do
-  local handle = fs.open(file.getName(), "wb")
-  handle.write(file.readAll())
-
-  handle.close()
-  file.close()
-end
-```

doc/events/http_check.md

@@ -3,18 +3,12 @@ module: [kind=event] http_check
 see: http.checkURLAsync To check a URL asynchronously.
 ---
 
-<!--
+The @{http_check} event is fired when a URL check finishes.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is normally handled inside @{http.checkURL}, but it can still be seen when using @{http.checkURLAsync}.
--->
-
-The [`http_check`] event is fired when a URL check finishes.
-
-This event is normally handled inside [`http.checkURL`], but it can still be seen when using [`http.checkURLAsync`].
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The URL requested to be checked.
+2. @{string}: The URL requested to be checked.
-3. [`boolean`]: Whether the check succeeded.
+3. @{boolean}: Whether the check succeeded.
-4. <span class="type">[`string`]|[`nil`]</span>: If the check failed, a reason explaining why the check failed.
+4. @{string|nil}: If the check failed, a reason explaining why the check failed.

doc/events/http_failure.md

@@ -3,22 +3,15 @@ module: [kind=event] http_failure
 see: http.request To send an HTTP request.
 ---
 
-<!--
+The @{http_failure} event is fired when an HTTP request fails.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is normally handled inside @{http.get} and @{http.post}, but it can still be seen when using @{http.request}.
--->
-
-The [`http_failure`] event is fired when an HTTP request fails.
-
-This event is normally handled inside [`http.get`] and [`http.post`], but it can still be seen when using [`http.request`].
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The URL of the site requested.
+2. @{string}: The URL of the site requested.
-3. [`string`]: An error describing the failure.
+3. @{string}: An error describing the failure.
-4. <span class="type">[`http.Response`]|[`nil`]</span>: A response handle if the connection succeeded, but the server's
+4. @{http.Response|nil}: A response handle if the connection succeeded, but the server's response indicated failure.
-   response indicated failure.
 
 ## Example
 Prints an error why the website cannot be contacted:

doc/events/http_success.md

@@ -3,20 +3,14 @@ module: [kind=event] http_success
 see: http.request To make an HTTP request.
 ---
 
-<!--
+The @{http_success} event is fired when an HTTP request returns successfully.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is normally handled inside @{http.get} and @{http.post}, but it can still be seen when using @{http.request}.
--->
-
-The [`http_success`] event is fired when an HTTP request returns successfully.
-
-This event is normally handled inside [`http.get`] and [`http.post`], but it can still be seen when using [`http.request`].
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The URL of the site requested.
+2. @{string}: The URL of the site requested.
-3. [`http.Response`]: The successful HTTP response.
+3. @{http.Response}: The handle for the response text.
 
 ## Example
 Prints the content of a website (this may fail if the request fails):

doc/events/key.md

@@ -2,24 +2,18 @@
 module: [kind=event] key
 ---
 
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 This event is fired when any key is pressed while the terminal is focused.
 
 This event returns a numerical "key code" (for instance, <kbd>F1</kbd> is 290). This value may vary between versions and
-so it is recommended to use the constants in the [`keys`] API rather than hard coding numeric values.
+so it is recommended to use the constants in the @{keys} API rather than hard coding numeric values.
 
-If the button pressed represented a printable character, then the [`key`] event will be followed immediately by a [`char`]
+If the button pressed represented a printable character, then the @{key} event will be followed immediately by a @{char}
-event. If you are consuming text input, use a [`char`] event instead!
+event. If you are consuming text input, use a @{char} event instead!
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The numerical key value of the key pressed.
+2. @{number}: The numerical key value of the key pressed.
-3. [`boolean`]: Whether the key event was generated while holding the key ([`true`]), rather than pressing it the first time ([`false`]).
+3. @{boolean}: Whether the key event was generated while holding the key (@{true}), rather than pressing it the first time (@{false}).
 
 ## Example
 Prints each key when the user presses it, and if the key is being held.

doc/events/key_up.md

@@ -3,23 +3,17 @@ module: [kind=event] key_up
 see: keys For a lookup table of the given keys.
 ---
 
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 Fired whenever a key is released (or the terminal is closed while a key was being pressed).
 
 This event returns a numerical "key code" (for instance, <kbd>F1</kbd> is 290). This value may vary between versions and
-so it is recommended to use the constants in the [`keys`] API rather than hard coding numeric values.
+so it is recommended to use the constants in the @{keys} API rather than hard coding numeric values.
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The numerical key value of the key pressed.
+2. @{number}: The numerical key value of the key pressed.
 
 ## Example
-Prints each key released on the keyboard whenever a [`key_up`] event is fired.
+Prints each key released on the keyboard whenever a @{key_up} event is fired.
 
 ```lua
 while true do

doc/events/modem_message.md

@@ -2,33 +2,21 @@
 module: [kind=event] modem_message
 ---
 
-<!--
+The @{modem_message} event is fired when a message is received on an open channel on any modem.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`modem_message`] event is fired when a message is received on an open channel on any [`modem`].
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The side of the modem that received the message.
+2. @{string}: The side of the modem that received the message.
-3. [`number`]: The channel that the message was sent on.
+3. @{number}: The channel that the message was sent on.
-4. [`number`]: The reply channel set by the sender.
+4. @{number}: The reply channel set by the sender.
-5. [`any`]: The message as sent by the sender.
+5. @{any}: The message as sent by the sender.
-6. <span class="type">[`number`]|[`nil`]</span>: The distance between the sender and the receiver in blocks, or [`nil`] if the message was sent between dimensions.
+6. @{number}: The distance between the sender and the receiver, in blocks (decimal).
 
 ## Example
-Wraps a [`modem`] peripheral, opens channel 0 for listening, and prints all received messages.
+Prints a message when one is sent:
-
 ```lua
-local modem = peripheral.find("modem") or error("No modem attached", 0)
-modem.open(0)
-
 while true do
   local event, side, channel, replyChannel, message, distance = os.pullEvent("modem_message")
-    print(("Message received on side %s on channel %d (reply to %d) from %f blocks away with message %s"):format(
+  print(("Message received on side %s on channel %d (reply to %d) from %f blocks away with message %s"):format(side, channel, replyChannel, distance, tostring(message)))
-        side, channel, replyChannel, distance, tostring(message)
-    ))
 end
 ```

doc/events/monitor_resize.md

@@ -2,21 +2,14 @@
 module: [kind=event] monitor_resize
 ---
 
-<!--
+The @{monitor_resize} event is fired when an adjacent or networked monitor's size is changed.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`monitor_resize`] event is fired when an adjacent or networked monitor's size is changed.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The side or network ID of the monitor that was resized.
+2. @{string}: The side or network ID of the monitor that resized.
 
 ## Example
 Prints a message when a monitor is resized:
-
 ```lua
 while true do
   local event, side = os.pullEvent("monitor_resize")

doc/events/monitor_touch.md

@@ -2,19 +2,13 @@
 module: [kind=event] monitor_touch
 ---
 
-<!--
+The @{monitor_touch} event is fired when an adjacent or networked Advanced Monitor is right-clicked.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`monitor_touch`] event is fired when an adjacent or networked Advanced Monitor is right-clicked.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The side or network ID of the monitor that was touched.
+2. @{string}: The side or network ID of the monitor that was touched.
-3. [`number`]: The X coordinate of the touch, in characters.
+3. @{number}: The X coordinate of the touch, in characters.
-4. [`number`]: The Y coordinate of the touch, in characters.
+4. @{number}: The Y coordinate of the touch, in characters.
 
 ## Example
 Prints a message when a monitor is touched:

doc/events/mouse_click.md

@@ -2,30 +2,26 @@
 module: [kind=event] mouse_click
 ---
 
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 This event is fired when the terminal is clicked with a mouse. This event is only fired on advanced computers (including
 advanced turtles and pocket computers).
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The mouse button that was clicked.
+2. @{number}: The mouse button that was clicked.
-3. [`number`]: The X-coordinate of the click.
+3. @{number}: The X-coordinate of the click.
-4. [`number`]: The Y-coordinate of the click.
+4. @{number}: The Y-coordinate of the click.
 
 ## Mouse buttons
-Several mouse events ([`mouse_click`], [`mouse_up`], [`mouse_scroll`]) contain a "mouse button" code. This takes a
+Several mouse events (@{mouse_click}, @{mouse_up}, @{mouse_scroll}) contain a "mouse button" code. This takes a
 numerical value depending on which button on your mouse was last pressed when this event occurred.
 
-| Button Code | Mouse Button  |
+<table class="pretty-table">
-|------------:|---------------|
+    <!-- Our markdown parser doesn't work on tables!? Guess I'll have to roll my own soonish :/. -->
-|           1 | Left button   |
+    <tr><th>Button code</th><th>Mouse button</th></tr>
-|           2 | Right button  |
+    <tr><td align="right">1</td><td>Left button</td></tr>
-|           3 | Middle button |
+    <tr><td align="right">2</td><td>Middle button</td></tr>
+    <tr><td align="right">3</td><td>Right button</td></tr>
+</table>
 
 ## Example
 Print the button and the coordinates whenever the mouse is clicked.

doc/events/mouse_drag.md

@@ -3,19 +3,13 @@ module: [kind=event] mouse_drag
 see: mouse_click For when a mouse button is initially pressed.
 ---
 
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 This event is fired every time the mouse is moved while a mouse button is being held.
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The [mouse button](mouse_click.html#Mouse_buttons) that is being pressed.
+2. @{number}: The [mouse button](mouse_click.html#Mouse_buttons) that is being pressed.
-3. [`number`]: The X-coordinate of the mouse.
+3. @{number}: The X-coordinate of the mouse.
-4. [`number`]: The Y-coordinate of the mouse.
+4. @{number}: The Y-coordinate of the mouse.
 
 ## Example
 Print the button and the coordinates whenever the mouse is dragged.

doc/events/mouse_scroll.md

@@ -2,19 +2,13 @@
 module: [kind=event] mouse_scroll
 ---
 
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 This event is fired when a mouse wheel is scrolled in the terminal.
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The direction of the scroll. (-1 = up, 1 = down)
+2. @{number}: The direction of the scroll. (-1 = up, 1 = down)
-3. [`number`]: The X-coordinate of the mouse when scrolling.
+3. @{number}: The X-coordinate of the mouse when scrolling.
-4. [`number`]: The Y-coordinate of the mouse when scrolling.
+4. @{number}: The Y-coordinate of the mouse when scrolling.
 
 ## Example
 Prints the direction of each scroll, and the position of the mouse at the time.

doc/events/mouse_up.md

@@ -2,19 +2,13 @@
 module: [kind=event] mouse_up
 ---
 
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 This event is fired when a mouse button is released or a held mouse leaves the computer's terminal.
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The [mouse button](mouse_click.html#Mouse_buttons) that was released.
+2. @{number}: The [mouse button](mouse_click.html#Mouse_buttons) that was released.
-3. [`number`]: The X-coordinate of the mouse.
+3. @{number}: The X-coordinate of the mouse.
-4. [`number`]: The Y-coordinate of the mouse.
+4. @{number}: The Y-coordinate of the mouse.
 
 ## Example
 Prints the coordinates and button number whenever the mouse is released.

doc/events/paste.md

@@ -2,17 +2,11 @@
 module: [kind=event] paste
 ---
 
-<!--
+The @{paste} event is fired when text is pasted into the computer through Ctrl-V (or ⌘V on Mac).
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`paste`] event is fired when text is pasted into the computer through Ctrl-V (or ⌘V on Mac).
 
 ## Return values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`] The text that was pasted.
+2. @{string} The text that was pasted.
 
 ## Example
 Prints pasted text:

doc/events/peripheral.md

@@ -3,17 +3,11 @@ module: [kind=event] peripheral
 see: peripheral_detach For the event fired when a peripheral is detached.
 ---
 
-<!--
+The @{peripheral} event is fired when a peripheral is attached on a side or to a modem.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`peripheral`] event is fired when a peripheral is attached on a side or to a modem.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The side the peripheral was attached to.
+2. @{string}: The side the peripheral was attached to.
 
 ## Example
 Prints a message when a peripheral is attached:

doc/events/peripheral_detach.md

@@ -3,17 +3,11 @@ module: [kind=event] peripheral_detach
 see: peripheral For the event fired when a peripheral is attached.
 ---
 
-<!--
+The @{peripheral_detach} event is fired when a peripheral is detached from a side or from a modem.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`peripheral_detach`] event is fired when a peripheral is detached from a side or from a modem.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The side the peripheral was detached from.
+2. @{string}: The side the peripheral was detached from.
 
 ## Example
 Prints a message when a peripheral is detached:

doc/events/rednet_message.md

@@ -4,23 +4,17 @@ see: modem_message For raw modem messages sent outside of Rednet.
 see: rednet.receive To wait for a Rednet message with an optional timeout and protocol filter.
 ---
 
-<!--
+The @{rednet_message} event is fired when a message is sent over Rednet.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is usually handled by @{rednet.receive}, but it can also be pulled manually.
--->
 
-The [`rednet_message`] event is fired when a message is sent over Rednet.
+@{rednet_message} events are sent by @{rednet.run} in the top-level coroutine in response to @{modem_message} events. A @{rednet_message} event is always preceded by a @{modem_message} event. They are generated inside CraftOS rather than being sent by the ComputerCraft machine.
-
-This event is usually handled by [`rednet.receive`], but it can also be pulled manually.
-
-[`rednet_message`] events are sent by [`rednet.run`] in the top-level coroutine in response to [`modem_message`] events. A [`rednet_message`] event is always preceded by a [`modem_message`] event. They are generated inside CraftOS rather than being sent by the ComputerCraft machine.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The ID of the sending computer.
+2. @{number}: The ID of the sending computer.
-3. [`any`]: The message sent.
+3. @{any}: The message sent.
-4. <span class="type">[`string`]|[`nil`]</span>: The protocol of the message, if provided.
+4. @{string|nil}: The protocol of the message, if provided.
 
 ## Example
 Prints a message when one is sent:

doc/events/redstone.md

@@ -2,16 +2,7 @@
 module: [kind=event] redstone
 ---
 
-<!--
+The @{redstone} event is fired whenever any redstone inputs on the computer change.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`event!redstone`] event is fired whenever any redstone inputs on the computer change.
-
-## Return values
-1. [`string`]: The event name.
 
 ## Example
 Prints a message when a redstone input changes:

doc/events/speaker_audio_empty.md

@@ -1,33 +0,0 @@
----
-module: [kind=event] speaker_audio_empty
-see: speaker.playAudio To play audio using the speaker
----
-
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-## Return Values
-1. [`string`]: The event name.
-2. [`string`]: The name of the speaker which is available to play more audio.
-
-
-## Example
-This uses [`io.lines`] to read audio data in blocks of 16KiB from "example_song.dfpwm", and then attempts to play it
-using [`speaker.playAudio`]. If the speaker's buffer is full, it waits for an event and tries again.
-
-```lua {data-peripheral=speaker}
-local dfpwm = require("cc.audio.dfpwm")
-local speaker = peripheral.find("speaker")
-
-local decoder = dfpwm.make_decoder()
-for chunk in io.lines("data/example.dfpwm", 16 * 1024) do
-    local buffer = decoder(chunk)
-
-    while not speaker.playAudio(buffer) do
-        os.pullEvent("speaker_audio_empty")
-    end
-end
-```

doc/events/task_complete.md

@@ -3,20 +3,14 @@ module: [kind=event] task_complete
 see: commands.execAsync To run a command which fires a task_complete event.
 ---
 
-<!--
+The @{task_complete} event is fired when an asynchronous task completes. This is usually handled inside the function call that queued the task; however, functions such as @{commands.execAsync} return immediately so the user can wait for completion.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`task_complete`] event is fired when an asynchronous task completes. This is usually handled inside the function call that queued the task; however, functions such as [`commands.execAsync`] return immediately so the user can wait for completion.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The ID of the task that completed.
+2. @{number}: The ID of the task that completed.
-3. [`boolean`]: Whether the command succeeded.
+3. @{boolean}: Whether the command succeeded.
-4. [`string`]: If the command failed, an error message explaining the failure. (This is not present if the command succeeded.)
+4. @{string}: If the command failed, an error message explaining the failure. (This is not present if the command succeeded.)
-5. <abbr title="Variable number of arguments">&hellip;</abbr>: Any parameters returned from the command.
+...: Any parameters returned from the command.
 
 ## Example
 Prints the results of an asynchronous command:

doc/events/term_resize.md

@@ -2,25 +2,10 @@
 module: [kind=event] term_resize
 ---
 
-<!--
+The @{term_resize} event is fired when the main terminal is resized, mainly when a new tab is opened or closed in @{multishell}.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`term_resize`] event is fired when the main terminal is resized. For instance:
- - When a the tab bar is shown or hidden in [`multishell`].
- - When the terminal is redirected to a monitor via the "monitor" program and the monitor is resized.
-
-When this event fires, some parts of the terminal may have been moved or deleted. Simple terminal programs (those
-not using [`term.setCursorPos`]) can ignore this event, but more complex GUI programs should redraw the entire screen.
-
-## Return values
-1. [`string`]: The event name.
 
 ## Example
-Print a message each time the terminal is resized.
+Prints :
-
 ```lua
 while true do
   os.pullEvent("term_resize")

doc/events/terminate.md

@@ -2,20 +2,11 @@
 module: [kind=event] terminate
 ---
 
-<!--
+The @{terminate} event is fired when <kbd>Ctrl-T</kbd> is held down.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is normally handled by @{os.pullEvent}, and will not be returned. However, @{os.pullEventRaw} will return this event when fired.
--->
 
-The [`terminate`] event is fired when <kbd>Ctrl-T</kbd> is held down.
+@{terminate} will be sent even when a filter is provided to @{os.pullEventRaw}. When using @{os.pullEventRaw} with a filter, make sure to check that the event is not @{terminate}.
-
-This event is normally handled by [`os.pullEvent`], and will not be returned. However, [`os.pullEventRaw`] will return this event when fired.
-
-[`terminate`] will be sent even when a filter is provided to [`os.pullEventRaw`]. When using [`os.pullEventRaw`] with a filter, make sure to check that the event is not [`terminate`].
-
-## Return values
-1. [`string`]: The event name.
 
 ## Example
 Prints a message when Ctrl-T is held:

doc/events/timer.md

@@ -3,25 +3,19 @@ module: [kind=event] timer
 see: os.startTimer To start a timer.
 ---
 
-<!--
+The @{timer} event is fired when a timer started with @{os.startTimer} completes.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`timer`] event is fired when a timer started with [`os.startTimer`] completes.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`number`]: The ID of the timer that finished.
+2. @{number}: The ID of the timer that finished.
 
 ## Example
-Start and wait for a timer to finish.
+Starts a timer and then prints its ID:
 ```lua
-local timer_id = os.startTimer(2)
+local timerID = os.startTimer(2)
 local event, id
 repeat
     event, id = os.pullEvent("timer")
-until id == timer_id
+until id == timerID
 print("Timer with ID " .. id .. " was fired")
 ```

doc/events/turtle_inventory.md

@@ -2,16 +2,7 @@
 module: [kind=event] turtle_inventory
 ---
 
-<!--
+The @{turtle_inventory} event is fired when a turtle's inventory is changed.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`turtle_inventory`] event is fired when a turtle's inventory is changed.
-
-## Return values
-1. [`string`]: The event name.
 
 ## Example
 Prints a message when the inventory is changed:

doc/events/websocket_closed.md

@@ -2,26 +2,11 @@
 module: [kind=event] websocket_closed
 ---
 
-<!--
+The @{websocket_closed} event is fired when an open WebSocket connection is closed.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-The [`websocket_closed`] event is fired when an open WebSocket connection is closed.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The URL of the WebSocket that was closed.
+2. @{string}: The URL of the WebSocket that was closed.
-3. <span class="type">[`string`]|[`nil`]</span>: The [server-provided reason][close_reason]
-   the websocket was closed. This will be [`nil`] if the connection was closed
-   abnormally.
-4. <span class="type">[`number`]|[`nil`]</span>: The [connection close code][close_code],
-   indicating why the socket was closed. This will be [`nil`] if the connection
-   was closed abnormally.
-
-[close_reason]: https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.6 "The WebSocket Connection Close Reason, RFC 6455"
-[close_code]: https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5 "The WebSocket Connection Close Code, RFC 6455"
 
 ## Example
 Prints a message when a WebSocket is closed (this may take a minute):

doc/events/websocket_failure.md

@@ -3,20 +3,14 @@ module: [kind=event] websocket_failure
 see: http.websocketAsync To send an HTTP request.
 ---
 
-<!--
+The @{websocket_failure} event is fired when a WebSocket connection request fails.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is normally handled inside @{http.websocket}, but it can still be seen when using @{http.websocketAsync}.
--->
-
-The [`websocket_failure`] event is fired when a WebSocket connection request fails.
-
-This event is normally handled inside [`http.websocket`], but it can still be seen when using [`http.websocketAsync`].
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The URL of the site requested.
+2. @{string}: The URL of the site requested.
-3. [`string`]: An error describing the failure.
+3. @{string}: An error describing the failure.
 
 ## Example
 Prints an error why the website cannot be contacted:

doc/events/websocket_message.md

@@ -2,21 +2,14 @@
 module: [kind=event] websocket_message
 ---
 
-<!--
+The @{websocket_message} event is fired when a message is received on an open WebSocket connection.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is normally handled by @{http.Websocket.receive}, but it can also be pulled manually.
--->
-
-The [`websocket_message`] event is fired when a message is received on an open WebSocket connection.
-
-This event is normally handled by [`http.Websocket.receive`], but it can also be pulled manually.
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The URL of the WebSocket.
+2. @{string}: The URL of the WebSocket.
-3. [`string`]: The contents of the message.
+3. @{string}: The contents of the message.
-4. [`boolean`]: Whether this is a binary message.
 
 ## Example
 Prints a message sent by a WebSocket:

doc/events/websocket_success.md

@@ -3,20 +3,14 @@ module: [kind=event] websocket_success
 see: http.websocketAsync To open a WebSocket asynchronously.
 ---
 
-<!--
+The @{websocket_success} event is fired when a WebSocket connection request returns successfully.
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 
-SPDX-License-Identifier: MPL-2.0
+This event is normally handled inside @{http.websocket}, but it can still be seen when using @{http.websocketAsync}.
--->
-
-The [`websocket_success`] event is fired when a WebSocket connection request returns successfully.
-
-This event is normally handled inside [`http.websocket`], but it can still be seen when using [`http.websocketAsync`].
 
 ## Return Values
-1. [`string`]: The event name.
+1. @{string}: The event name.
-2. [`string`]: The URL of the site.
+2. @{string}: The URL of the site.
-3. [`http.Websocket`]: The handle for the WebSocket.
+3. @{http.Websocket}: The handle for the WebSocket.
 
 ## Example
 Prints the content of a website (this may fail if the request fails):

doc/guides/gps_setup.md

@@ -1,93 +0,0 @@
----
-module: [kind=guide] gps_setup
----
-
-<!--
-SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-# Setting up GPS
-The [`gps`] API allows computers and turtles to find their current position using wireless modems.
-
-In order to use GPS, you'll need to set up multiple *GPS hosts*. These are computers running the special `gps host`
-program, which tell other computers the host's position. Several hosts running together are known as a *GPS
-constellation*.
-
-In order to give the best results, a GPS constellation needs at least four computers. More than four GPS hosts per
-constellation is redundant, but it does not cause problems.
-
-## Building a GPS constellation
-<img alt="An example GPS constellation." src="../images/gps-constellation-example.png" class="big-image" />
-
-We are going to build our GPS constellation as shown in the image above. You will need 4 computers and either 4 wireless
-modems or 4 ender modems. Try not to mix ender and wireless modems together as you might get some odd behavior when your
-requesting computers are out of range.
-
-> [Ender modems vs wireless modems][!TIP]
-> Ender modems have a very large range, which makes them very useful for setting up GPS hosts. If you do this then you
-> will likely only need one GPS constellation for the whole dimension (such as the Overworld or Nether).
->
-> If you do use wireless modems then you may find that you need multiple GPS constellations to cover your needs.
->
-> A computer needs a wireless or ender modem and to be in range of a GPS constellation that is in the same dimension as
-> it to use the GPS API. The reason for this is that ComputerCraft mimics real-life GPS by making use of the distance
-> parameter of [modem messages][`modem_message`] and some maths.
-
-Locate where you want to place your GPS constellation. You will need an area at least 6 blocks high, 6 blocks wide, and
-6 blocks deep (6x6x6). If you are using wireless modems then you may want to build your constellation as high as you can
-because high altitude boosts modem message range and thus the radius that your constellation covers.
-
-The GPS constellation will only work when it is in a loaded chunk. If you want your constellation to always be
-accessible, you may want to permanently load the chunk using a vanilla or modded chunk loader. Make sure that your 6x6x6
-area fits in a single chunk to reduce the number of chunks that need to be kept loaded.
-
-Let's get started building the constellation! Place your first computer in one of the corners of your 6x6x6. Remember
-which computer this is as other computers need to be placed relative to it. Place the second computer 4 blocks above the
-first. Go back to your first computer and place your third computer 5 blocks in front of your first computer, leaving 4
-blocks of air between them. Finally for the fourth computer, go back to your first computer and place it 5 blocks right
-of your first computer, leaving 4 blocks of air between them.
-
-With all four computers placed within the 6x6x6, place one modem on top of each computer. You should have 4 modems and 4
-computers all within your 6x6x6 where each modem is attached to a computer and each computer has a modem.
-
-Currently your GPS constellation will not work, that's because each host is not aware that it's a GPS host. We will fix
-this in the next section.
-
-## Configuring the constellation
-Now that the structure of your constellation is built, we need to configure each host in it.
-
-Go back to the first computer that you placed and create a startup file, by running `edit startup`.
-
-Type the following code into the file:
-```lua
-shell.run("gps", "host", x, y, z)
-```
-
-Escape from the computer GUI and then press <kbd>F3</kbd> to open Minecraft's debug screen and then look at the computer
-(without opening the GUI). On the right of the screen about halfway down you should see an entry labeled `Targeted
-Block`, the numbers correspond to the position of the block that you are looking at. Replace `x` with the first number,
-`y` with the second number, and `z` with the third number.
-
-For example, if I had a computer at x = 59, y = 5, z = -150, then my <kbd>F3</kbd> debug screen entry would be `Target
-Block: 59, 5, -150` and I would change my startup file to this `shell.run("gps", "host", 59, 5, -150)`.
-
-To hide Minecraft's debug screen, press <kbd>F3</kbd> again.
-
-Create similar startup files for the other computers in your constellation, making sure to input the each computer's own
-coordinates.
-
-> [Modem messages come from the computer's position, not the modem's][!WARNING]
-> Wireless modems transmit from the block that they are attached to *not* the block space that they occupy, the
-> coordinates that you input into your GPS host should be the position of the computer and not the position of the modem.
-
-Congratulations, your constellation is now fully set up! You can test it by placing another computer close by, placing a
-wireless modem on it, and running the `gps locate` program (or calling the [`gps.locate`] function).
-
-> [Why use Minecraft's coordinates?][!INFO]
-> CC doesn't care if you use Minecraft's coordinate system, so long as all of the GPS hosts with overlapping ranges use
-> the same reference point (requesting computers will get confused if hosts have different reference points). However,
-> using MC's coordinate system does provide a nice standard to adopt server-wide. It also is consistent with how command
-> computers get their location, they use MC's command system to get their block which returns that in MC's coordinate
-> system.

doc/guides/local_ips.md

@@ -1,105 +0,0 @@
----
-module: [kind=guide] local_ips
----
-
-<!--
-SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-# Allowing access to local IPs
-By default, ComputerCraft blocks access to local IP addresses for security. This means you can't normally access any
-HTTP server running on your computer. However, this may be useful for testing programs without having a remote
-server. You can unblock these IPs in the ComputerCraft config.
-
- - [Minecraft 1.13 and later, CC:T 1.87.0 and later](#cc-1.87.0)
- - [Minecraft 1.13 and later, CC:T 1.86.2 and earlier](#cc-1.86.2)
- - [Minecraft 1.12.2 and earlier](#mc-1.12)
-
-## Minecraft 1.13 and later, CC:T 1.87.0 and later {#cc-1.87.0}
-The configuration file can be located at `serverconfig/computercraft-server.toml` inside the world folder on either
-single-player or multiplayer. Look for lines that look like this:
-
-```toml
-#A list of rules which control behaviour of the "http" API for specific domains or IPs.
-#Each rule is an item with a 'host' to match against, and a series of properties. The host may be a domain name ("pastebin.com"),
-#wildcard ("*.pastebin.com") or CIDR notation ("127.0.0.0/8"). If no rules, the domain is blocked.
-[[http.rules]]
-    host = "$private"
-    action = "deny"
-```
-
-On 1.95.0 and later, this will be a single entry with `host = "$private"`. On earlier versions, this will be a number of
-`[[http.rules]]` with various IP addresses. You will want to remove all of the `[[http.rules]]` entries that have
-`action = "deny"`. Then save the file and relaunch Minecraft (Server).
-
-Here's what it should look like after removing:
-
-```toml
-#A list of rules which control behaviour of the "http" API for specific domains or IPs.
-#Each rule is an item with a 'host' to match against, and a series of properties. The host may be a domain name ("pastebin.com"),
-#wildcard ("*.pastebin.com") or CIDR notation ("127.0.0.0/8"). If no rules, the domain is blocked.
-[[http.rules]]
-    #The maximum size (in bytes) that a computer can send or receive in one websocket packet.
-    max_websocket_message = 131072
-    host = "*"
-    #The maximum size (in bytes) that a computer can upload in a single request. This includes headers and POST text.
-    max_upload = 4194304
-    action = "allow"
-    #The maximum size (in bytes) that a computer can download in a single request. Note that responses may receive more data than allowed, but this data will not be returned to the client.
-    max_download = 16777216
-    #The period of time (in milliseconds) to wait before a HTTP request times out. Set to 0 for unlimited.
-    timeout = 30000
-```
-
-## Minecraft 1.13 and later, CC:T 1.86.2 and earlier {#cc-1.86.2}
-The configuration file for singleplayer is at `.minecraft/config/computercraft-common.toml`. Look for lines that look
-like this:
-
-```toml
-#A list of wildcards for domains or IP ranges that cannot be accessed through the "http" API on Computers.
-#If this is empty then all whitelisted domains will be accessible. Example: "*.github.com" will block access to all subdomains of github.com.
-#You can use domain names ("pastebin.com"), wildcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
-blacklist = ["127.0.0.0/8", "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "fd00::/8"]
-```
-
-Remove everything inside the array, leaving the last line as `blacklist = []`. Then save the file and relaunch Minecraft.
-
-Here's what it should look like after removing:
-
-```toml
-#A list of wildcards for domains or IP ranges that cannot be accessed through the "http" API on Computers.
-#If this is empty then all whitelisted domains will be accessible. Example: "*.github.com" will block access to all subdomains of github.com.
-#You can use domain names ("pastebin.com"), wildcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
-blacklist = []
-```
-
-## Minecraft 1.12.2 and earlier {#mc-1.12}
-On singleplayer, the configuration file is located at `.minecraft\config\ComputerCraft.cfg`. On multiplayer, the
-configuration file is located at `<server folder>\config\ComputerCraft.cfg`. Look for lines that look like this:
-
-```ini
-# A list of wildcards for domains or IP ranges that cannot be accessed through the "http" API on Computers.
-# If this is empty then all explicitly allowed domains will be accessible. Example: "*.github.com" will block access to all subdomains of github.com.
-# You can use domain names ("pastebin.com"), wildcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
-S:blocked_domains <
-    127.0.0.0/8
-    10.0.0.0/8
-    172.16.0.0/12
-    192.168.0.0/16
-    fd00::/8
- >
-```
-
-Delete everything between the `<>`, leaving the last line as `S:blocked_domains = <>`. Then save the file and relaunch
-Minecraft (Server).
-
-Here's what it should look like after removing:
-
-```ini
-# A list of wildcards for domains or IP ranges that cannot be accessed through the "http" API on Computers.
-# If this is empty then all explicitly allowed domains will be accessible. Example: "*.github.com" will block access to all subdomains of github.com.
-# You can use domain names ("pastebin.com"), wildcards ("*.pastebin.com") or CIDR notation ("127.0.0.0/8").
-S:blocked_domains <>
-```

doc/guides/speaker_audio.md

@@ -1,209 +0,0 @@
----
-module: [kind=guide] speaker_audio
-see: speaker.playAudio Play PCM audio using a speaker.
-see: cc.audio.dfpwm Provides utilities for encoding and decoding DFPWM files.
----
-
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-# Playing audio with speakers
-CC: Tweaked's speaker peripheral provides a powerful way to play any audio you like with the [`speaker.playAudio`]
-method. However, for people unfamiliar with digital audio, it's not the most intuitive thing to use. This guide provides
-an introduction to digital audio, demonstrates how to play music with CC: Tweaked's speakers, and then briefly discusses
-the more complex topic of audio processing.
-
-## A short introduction to digital audio
-When sound is recorded it is captured as an analogue signal, effectively the electrical version of a sound
-wave. However, this signal is continuous, and so can't be used directly by a computer. Instead, we measure (or *sample*)
-the amplitude of the wave many times a second and then *quantise* that amplitude, rounding it to the nearest
-representable value.
-
-This representation of sound - a long, uniformally sampled list of amplitudes is referred to as [Pulse-code
-Modulation][PCM] (PCM). PCM can be thought of as the "standard" audio format, as it's incredibly easy to work with. For
-instance, to mix two pieces of audio together, you can just add samples from the two tracks together and take the average.
-
-CC: Tweaked's speakers also work with PCM audio. It plays back 48,000 samples a second, where each sample is an integer
-between -128 and 127. This is more commonly referred to as 48kHz and an 8-bit resolution.
-
-Let's now look at a quick example. We're going to generate a [Sine Wave] at 220Hz, which sounds like a low monotonous
-hum. First we wrap our speaker peripheral, and then we fill a table (also referred to as a *buffer*) with 128×1024
-samples - this is the maximum number of samples a speaker can accept in one go.
-
-In order to fill this buffer, we need to do a little maths. We want to play 220 sine waves each second, where each sine
-wave completes a full oscillation in 2π "units". This means one seconds worth of audio is 2×π×220 "units" long. We then
-need to split this into 48k samples, basically meaning for each sample we move 2×π×220/48k "along" the sine curve.
-
-```lua {data-peripheral=speaker}
-local speaker = peripheral.find("speaker")
-
-local buffer = {}
-local t, dt = 0, 2 * math.pi * 220 / 48000
-for i = 1, 128 * 1024 do
-    buffer[i] = math.floor(math.sin(t) * 127)
-    t = (t + dt) % (math.pi * 2)
-end
-
-speaker.playAudio(buffer)
-```
-
-## Streaming audio
-You might notice that the above snippet only generates a short bit of audio - 2.7s seconds to be precise. While we could
-try increasing the number of loop iterations, we'll get an error when we try to play it through the speaker: the sound
-buffer is too large for it to handle.
-
-Our 2.7 seconds of audio is stored in a table with over 130 _thousand_ elements. If we wanted to play a full minute of
-sine waves (and why wouldn't you?), you'd need a table with almost 3 _million_. Suddenly you find these numbers adding
-up very quickly, and these tables take up more and more memory.
-
-Instead of building our entire song (well, sine wave) in one go, we can produce it in small batches, each of which get
-passed off to [`speaker.playAudio`] when the time is right. This allows us to build a _stream_ of audio, where we read
-chunks of audio one at a time (either from a file or a tone generator like above), do some optional processing to each
-one, and then play them.
-
-Let's adapt our example from above to do that instead.
-
-```lua {data-peripheral=speaker}
-local speaker = peripheral.find("speaker")
-
-local t, dt = 0, 2 * math.pi * 220 / 48000
-while true do
-    local buffer = {}
-    for i = 1, 16 * 1024 * 8 do
-        buffer[i] = math.floor(math.sin(t) * 127)
-        t = (t + dt) % (math.pi * 2)
-    end
-
-    while not speaker.playAudio(buffer) do
-        os.pullEvent("speaker_audio_empty")
-    end
-end
-```
-
-It looks pretty similar to before, aside from we've wrapped the generation and playing code in a while loop, and added a
-rather odd loop with [`speaker.playAudio`] and [`os.pullEvent`].
-
-Let's talk about this loop, why do we need to keep calling [`speaker.playAudio`]? Remember that what we're trying to do
-here is avoid keeping too much audio in memory at once. However, if we're generating audio quicker than the speakers can
-play it, we're not helping at all - all this audio is still hanging around waiting to be played!
-
-In order to avoid this, the speaker rejects any new chunks of audio if its backlog is too large. When this happens,
-[`speaker.playAudio`] returns false. Once enough audio has played, and the backlog has been reduced, a
-[`speaker_audio_empty`] event is queued, and we can try to play our chunk once more.
-
-## Storing audio
-PCM is a fantastic way of representing audio when we want to manipulate it, but it's not very efficient when we want to
-store it to disk. Compare the size of a WAV file (which uses PCM) to an equivalent MP3, it's often 5 times the size.
-Instead, we store audio in special formats (or *codecs*) and then convert them to PCM when we need to do processing on
-them.
-
-Modern audio codecs use some incredibly impressive techniques to compress the audio as much as possible while preserving
-sound quality. However, due to CC: Tweaked's limited processing power, it's not really possible to use these from your
-computer. Instead, we need something much simpler.
-
-DFPWM (Dynamic Filter Pulse Width Modulation) is the de facto standard audio format of the ComputerCraft (and
-OpenComputers) world. Originally popularised by the addon mod [Computronics], CC:T now has built-in support for it with
-the [`cc.audio.dfpwm`] module. This allows you to read DFPWM files from disk, decode them to PCM, and then play them
-using the speaker.
-
-Let's dive in with an example, and we'll explain things afterwards:
-
-```lua {data-peripheral=speaker}
-local dfpwm = require("cc.audio.dfpwm")
-local speaker = peripheral.find("speaker")
-
-local decoder = dfpwm.make_decoder()
-for chunk in io.lines("data/example.dfpwm", 16 * 1024) do
-    local buffer = decoder(chunk)
-
-    while not speaker.playAudio(buffer) do
-        os.pullEvent("speaker_audio_empty")
-    end
-end
-```
-
-Once again, we see the [`speaker.playAudio`]/[`speaker_audio_empty`] loop. However, the rest of the program is a little
-different.
-
-First, we require the dfpwm module and call [`cc.audio.dfpwm.make_decoder`] to construct a new decoder. This decoder
-accepts blocks of DFPWM data and converts it to a list of 8-bit amplitudes, which we can then play with our speaker.
-
-As mentioned above, [`speaker.playAudio`] accepts at most 128×1024 samples in one go. DFPMW uses a single bit for each
-sample, which means we want to process our audio in chunks of 16×1024 bytes (16KiB). In order to do this, we use
-[`io.lines`], which provides a nice way to loop over chunks of a file. You can of course just use [`fs.open`] and
-[`fs.ReadHandle.read`] if you prefer.
-
-## Processing audio
-As mentioned near the beginning of this guide, PCM audio is pretty easy to work with as it's just a list of amplitudes.
-You can mix together samples from different streams by adding their amplitudes, change the rate of playback by removing
-samples, etc...
-
-Let's put together a small demonstration here. We're going to add a small delay effect to the song above, so that you
-hear a faint echo a second and a half later.
-
-In order to do this, we'll follow a format similar to the previous example, decoding the audio and then playing it.
-However, we'll also add some new logic between those two steps, which loops over every sample in our chunk of audio, and
-adds the sample from 1.5 seconds ago to it.
-
-For this, we'll need to keep track of the last 72k samples - exactly 1.5 seconds worth of audio. We can do this using a
-[Ring Buffer], which helps makes things a little more efficient.
-
-```lua {data-peripheral=speaker}
-local dfpwm = require("cc.audio.dfpwm")
-local speaker = peripheral.find("speaker")
-
--- Speakers play at 48kHz, so 1.5 seconds is 72k samples. We first fill our buffer
--- with 0s, as there's nothing to echo at the start of the track!
-local samples_i, samples_n = 1, 48000 * 1.5
-local samples = {}
-for i = 1, samples_n do samples[i] = 0 end
-
-local decoder = dfpwm.make_decoder()
-for chunk in io.lines("data/example.dfpwm", 16 * 1024) do
-    local buffer = decoder(chunk)
-
-    for i = 1, #buffer do
-        local original_value = buffer[i]
-
-        -- Replace this sample with its current amplitude plus the amplitude from 1.5 seconds ago.
-        -- We scale both to ensure the resulting value is still between -128 and 127.
-        buffer[i] = original_value * 0.6 + samples[samples_i] * 0.4
-
-        -- Now store the current sample, and move the "head" of our ring buffer forward one place.
-        samples[samples_i] = original_value
-        samples_i = samples_i + 1
-        if samples_i > samples_n then samples_i = 1 end
-    end
-
-    while not speaker.playAudio(buffer) do
-        os.pullEvent("speaker_audio_empty")
-    end
-
-    -- The audio processing above can be quite slow and preparing the first batch of audio
-    -- may timeout the computer. We sleep to avoid this.
-    -- There's definitely better ways of handling this - this is just an example!
-    sleep(0.05)
-end
-```
-
-> [Confused?][!NOTE]
-> Don't worry if you don't understand this example. It's quite advanced, and does use some ideas that this guide doesn't
-> cover. That said, don't be afraid to ask on [GitHub Discussions] or [IRC] either!
-
-It's worth noting that the examples of audio processing we've mentioned here are about manipulating the _amplitude_ of
-the wave. If you wanted to modify the _frequency_ (for instance, shifting the pitch), things get rather more complex.
-For this, you'd need to use the [Fast Fourier transform][FFT] to convert the stream of amplitudes to frequencies,
-process those, and then convert them back to amplitudes.
-
-This is, I'm afraid, left as an exercise to the reader.
-
-[Computronics]: https://github.com/Vexatos/Computronics/ "Computronics on GitHub"
-[FFT]: https://en.wikipedia.org/wiki/Fast_Fourier_transform "Fast Fourier transform - Wikipedia"
-[PCM]: https://en.wikipedia.org/wiki/Pulse-code_modulation "Pulse-code Modulation - Wikipedia"
-[Ring Buffer]: https://en.wikipedia.org/wiki/Circular_buffer "Circular buffer - Wikipedia"
-[Sine Wave]: https://en.wikipedia.org/wiki/Sine_wave "Sine wave - Wikipedia"
-[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"

doc/guides/using_require.md

@@ -1,89 +0,0 @@
----
-module: [kind=guide] using_require
----
-
-<!--
-SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
-# Reusing code with require
-A library is a collection of useful functions and other definitions which is stored separately to your main program. You
-might want to create a library because you have some functions which are used in multiple programs, or just to split
-your program into multiple more modular files.
-
-Let's say we want to create a small library to make working with the [terminal][`term`] a little easier. We'll provide two
-functions: `reset`, which clears the terminal and sets the cursor to (1, 1), and `write_center`, which prints some text
-in the middle of the screen.
-
-Start off by creating a file called `more_term.lua`:
-
-```lua {data-snippet=more_term}
-local function reset()
-  term.clear()
-  term.setCursorPos(1, 1)
-end
-
-local function write_center(text)
-  local x, y = term.getCursorPos()
-  local width, height = term.getSize()
-  term.setCursorPos(math.floor((width - #text) / 2) + 1, y)
-  term.write(text)
-end
-
-return { reset = reset, write_center = write_center }
-```
-
-Now, what's going on here? We define our two functions as one might expect, and then at the bottom return a table with
-the two functions. When we require this library, this table is what is returned. With that, we can then call the
-original functions. Now create a new file, with the following:
-
-```lua {data-mount=more_term:more_term.lua}
-local more_term = require("more_term")
-more_term.reset()
-more_term.write_center("Hello, world!")
-```
-
-When run, this'll clear the screen and print some text in the middle of the first line.
-
-## require in depth
-While the previous section is a good introduction to how [`require`] operates, there are a couple of remaining points
-which are worth mentioning for more advanced usage.
-
-### Libraries can return anything
-In our above example, we return a table containing the functions we want to expose. However, it's worth pointing out
-that you can return ''anything'' from your library - a table, a function or even just a string! [`require`] treats them
-all the same, and just returns whatever your library provides.
-
-### Module resolution and the package path
-In the above examples, we defined our library in a file, and [`require`] read from it. While this is what you'll do most
-of the time, it is possible to make [`require`] look elsewhere for your library, such as downloading from a website or
-loading from an in-memory library store.
-
-As a result, the *module name* you pass to [`require`] doesn't correspond to a file path. One common mistake is to load
-code from a sub-directory using `require("folder/library")` or even `require("folder/library.lua")`, neither of which
-will do quite what you expect.
-
-When loading libraries (also referred to as *modules*) from files, [`require`] searches along the [*module
-path*][`package.path`]. By default, this looks something like:
-
-* `?.lua`
-* `?/init.lua`
-* `/rom/modules/main/?.lua`
-* etc...
-
-When you call `require("my_library")`, [`require`] replaces the `?` in each element of the path with your module name, and
-checks if the file exists. In this case, we'd look for `my_library.lua`, `my_library/init.lua`,
-`/rom/modules/main/my_library.lua` and so on. Note that this works *relative to the current program*, so if your
-program is actually called `folder/program`, then we'll look for `folder/my_library.lua`, etc...
-
-One other caveat is loading libraries from sub-directories. For instance, say we have a file
-`my/fancy/library.lua`. This can be loaded by using `require("my.fancy.library")` - the '.'s are replaced with '/'
-before we start looking for the library.
-
-## External links
-There are several external resources which go into require in a little more detail:
-
- - The [Lua Module tutorial](http://lua-users.org/wiki/ModulesTutorial) on the Lua wiki.
- - [Lua's manual section on `require`](https://www.lua.org/manual/5.1/manual.html#pdf-require).

doc/head.html

@@ -1,7 +1 @@
-<!--
-SPDX-FileCopyrightText: 2020 The CC: Tweaked Developers
-
-SPDX-License-Identifier: MPL-2.0
--->
-
 <meta name="theme-color" content="#c8d87c">