fix crash with non-unimix mixin loaders

The original permissions were written somewhat hastily, so this just cleans things up

.gitattributes

@@ -0,0 +1,44 @@
+* text eol=lf
+
+*.[jJ][aA][rR]          binary
+
+*.[pP][nN][gG]          binary
+*.[jJ][pP][gG]          binary
+*.[jJ][pP][eE][gG]      binary
+*.[gG][iI][fF]          binary
+*.[tT][iI][fF]          binary
+*.[tT][iI][fF][fF]      binary
+*.[iI][cC][oO]          binary
+*.[sS][vV][gG]          text
+*.[eE][pP][sS]          binary
+*.[xX][cC][fF]          binary
+
+*.[kK][aA][rR]          binary
+*.[mM]4[aA]             binary
+*.[mM][iI][dD]          binary
+*.[mM][iI][dD][iI]      binary
+*.[mM][pP]3             binary
+*.[oO][gG][gG]          binary
+*.[rR][aA]              binary
+
+*.7[zZ]                 binary
+*.[gG][zZ]              binary
+*.[tT][aA][rR]          binary
+*.[tT][gG][zZ]          binary
+*.[zZ][iI][pP]          binary
+
+*.[tT][cC][nN]          binary
+*.[sS][oO]              binary
+*.[dD][lL][lL]          binary
+*.[dD][yY][lL][iI][bB]  binary
+*.[pP][sS][dD]          binary
+*.[tT][tT][fF]          binary
+*.[oO][tT][fF]          binary
+
+*.[pP][aA][tT][cC][hH]  -text
+
+*.[bB][aA][tT]          text eol=crlf
+*.[cC][mM][dD]          text eol=crlf
+*.[pP][sS]1             text eol=crlf
+
+*[aA][uU][tT][oO][gG][eE][nN][eE][rR][aA][tT][eE][dD]* binary

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+patreon: falsepattern
+ko_fi: falsepattern

.github/scripts/test-no-error-reports.sh

@@ -1,51 +0,0 @@
-#!/usr/bin/env bash
-
-# bashsupport disable=BP5006 # Global environment variables
-RUNDIR="run" \
-  CRASH="crash-reports" \
-  SERVERLOG="server.log"
-
-# enable nullglob to get 0 results when no match rather than the pattern
-shopt -s nullglob
-
-# store matches in array
-crash_reports=("$RUNDIR/$CRASH/crash"*.txt)
-
-# if array not empty there are crash_reports
-if [ "${#crash_reports[@]}" -gt 0 ]; then
-  # get the latest crash_report from array
-  latest_crash_report="${crash_reports[-1]}"
-  {
-    printf 'Latest crash report detected %s:\n' "${latest_crash_report##*/}"
-    cat "$latest_crash_report"
-  } >&2
-  exit 1
-fi
-
-if grep --quiet --fixed-strings 'Fatal errors were detected' "$SERVERLOG"; then
-  {
-    printf 'Fatal errors detected:\n'
-    cat server.log
-  } >&2
-  exit 1
-fi
-
-if grep --quiet --fixed-strings 'The state engine was in incorrect state ERRORED and forced into state SERVER_STOPPED' \
-  "$SERVERLOG"; then
-  {
-    printf 'Server force stopped:'
-    cat server.log
-  } >&2
-  exit 1
-fi
-
-if ! grep --quiet --perl-regexp --only-matching '.+Done \(.+\)\! For help, type "help" or "\?"' "$SERVERLOG"; then
-  {
-    printf 'Server did not finish startup:'
-    cat server.log
-  } >&2
-  exit 1
-fi
-
-printf 'No crash reports detected'
-exit 0

.github/workflows/build-and-test.yml

@@ -1,45 +1,17 @@
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
-
 name: Build and test
 
 on:
   pull_request:
-    branches: [ master, main ]
+    branches:
+      - master
   push:
-    branches: [ master, main ]
+    branches:
+      - master
 
 jobs:
   build-and-test:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-      with: 
-        fetch-depth: 0
-    
-    - name: Set up JDK 8
-      uses: actions/setup-java@v2
-      with:
-        java-version: '8'
-        distribution: 'adopt'
-        cache: gradle
-        
-    - name: Grant execute permission for gradlew
-      run: chmod +x gradlew
-
-    - name: Setup the workspace
-      run: ./gradlew setupCIWorkspace
-
-    - name: Build the mod
-      run: ./gradlew build
-
-    - name: Run server for 1.5 minutes
-      run: |
-        mkdir run
-        echo "eula=true" > run/eula.txt  
-        timeout 90 ./gradlew runServer | tee --append server.log || true
-
-    - name: Test no errors reported during server run
-      run: |
-        chmod +x .github/scripts/test-no-error-reports.sh
-        .github/scripts/test-no-error-reports.sh
+    uses: FalsePattern/fpgradle-workflows/.github/workflows/build-and-test.yml@master
+    with:
+      timeout: 90
+      workspace: setupCIWorkspace
+      client-only: false

.github/workflows/release-tags.yml

@@ -1,50 +1,21 @@
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
-
-name: Release tagged build
+name: Release Tags
 
 on:
   push:
     tags:
       - '*'
 
+permissions:
+  contents: write
+
 jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
+  release-tags:
+    uses: FalsePattern/fpgradle-workflows/.github/workflows/release-tags.yml@master
+    with:
+      workspace: "setupCIWorkspace"
+    secrets:
+      MAVEN_DEPLOY_USER: ${{ secrets.MAVEN_DEPLOY_USER }}
+      MAVEN_DEPLOY_PASSWORD: ${{ secrets.MAVEN_DEPLOY_PASSWORD }}
+      MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
+      CURSEFORGE_TOKEN: ${{ secrets.CURSEFORGE_TOKEN }}
 
-      - name: Set release version
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-
-      - name: Set up JDK 8
-        uses: actions/setup-java@v2
-        with:
-          java-version: '8'
-          distribution: 'adopt'
-          cache: gradle
-
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-
-      - name: Setup the workspace
-        run: ./gradlew setupCIWorkspace
-
-      - name: Publish to Maven, Modrinth, and CurseForge
-        run: ./gradlew publish
-        env:
-          MAVEN_DEPLOY_USER: ${{ secrets.MAVEN_DEPLOY_USER }}
-          MAVEN_DEPLOY_PASSWORD: ${{ secrets.MAVEN_DEPLOY_PASSWORD }}
-          MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
-          CURSEFORGE_TOKEN: ${{ secrets.CURSEFORGE_TOKEN }}
-
-      - name: Release under current tag
-        uses: "marvinpinto/action-automatic-releases@latest"
-        with:
-          repo_token: "${{ secrets.GITHUB_TOKEN }}"
-          automatic_release_tag: "${{ env.RELEASE_VERSION }}"
-          prerelease: false
-          title: "${{ env.RELEASE_VERSION }}"
-          files: build/libs/*.jar

LICENSE

@@ -1,63 +1,746 @@
-#-------------------------------------------------------------------------------
-# @author FalsePattern
-#
-# Copyright 2023
-#
-# All rights reserved.
-# Distribution of the software in any form is only allowed with
-# explicit, prior permission from the owner.
-#-------------------------------------------------------------------------------
-@author FalsePattern
+ChunkAPI
 
+Copyright (C) 2023-2024 FalsePattern
+All Rights Reserved
 
-This code is the property of and owned and copyrighted by FalsePattern.
-This code is provided under a modified visible-source license
-that is as follows:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions of the Software.
 
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
 
-API Code:
-==============================
-API code is identifiable as being in an "API" package in the respective
-repository or mod, and is intended to allow some level of inter-mod
-interactions without creating hard dependencies on the mod proper. This code
-is exempt from the below restrictions for "Mod Code", as it by nature will
-require some level of copying and redistribution.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
 
-The only restrictions imposed on API code are that it remain clearly marked
-with its original authorship and source, that it be used for the purpose
-described previously, and that it not be modified from the original without
-first contacting FalsePattern.
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+This program comes with additional permissions according to Section 7 of the
+GNU Affero General Public License. See the full LICENSE file for details.
+-------------------------------------------------------------------------------
+According to Section 7 of the GNU Affero General Public License, this mod
+comes with the following additional permissions, as well as a possibility of
+re-licensing in case the official version is abandoned for an extended period
+of time:
 
-Mod Code:
-==============================
-Any and all users are permitted to use the source for educational purposes,
-or to create derivative works for private use only. GitHub forks and direct
-downloads are considered derivative works.
+A. Definitions.
+"The Game" refers to Minecraft: Java Edition and its dependencies, developed
+by Mojang Studios, as well as all of its former releases under the name
+Minecraft.
 
-Unless given explicit written permission - verifiable electronic writing is
-acceptable - no user may redistribute this source code nor any derivative
-works. These pre-approved works must prominently contain this copyright notice.
+"Mod" refers to a third-party modification for The Game.
 
-Derivative mods using any or all of the source code or assets are
-EXPRESSLY FORBIDDEN.
+"Modpack" refers to a collection of Mods, which may be independent of
+each other, or connected through various linking mechanisms.
 
-Additionally, no attempt may be made to achieve monetary gain from this code
-by anyone except the original author. In the case of pre-approved derivative
-works, any monetary gains made will be shared between the original author and
-the other developer(s), proportional to the ratio of derived to original code.
+"This Mod" refers to ChunkAPI.
 
-Finally, any and all displays, duplicates or derivatives of this code must be
-prominently marked as such, and must contain attribution to the original
-author, including a link to the original source. Any attempts to claim credit
-for this code will be treated as intentional theft.
+"API" refers to the part of This Mod that is designed to be linked against
+by other Mods.
 
-Due to the Mojang and Minecraft Mod Terms of Service and Licensing
-Restrictions, compiled versions of this code must be provided for free.
-However, with the exception of pre-approved derivative works, only the original
-author's modpacks may distribute compiled binary versions of this code.
+B. Additional Permissions.
 
-==============================
+You may link This Mod against the proprietary code of The Game, as well as
+distribute binary builds of it as part of a Modpack without the AGPL
+restrictions spreading to any other files in that Modpack.
 
-Failure to comply with these restrictions is a violation of copyright law and
-will be dealt with accordingly.
+You may also develop any Mod that depends on the API of This Mod and
+distribute that mod under terms of your own choice. Note that this specific
+permission does not apply to anything not explicitly specified as the API, as
+those are internal implementation details of This Mod, and as such are not
+designed to be used in any third-party Mod, thus the full force of the AGPL
+applies to such code.
+
+C. Termination of Additional Permissions.
+
+The additional permissions from Section B get removed from your copy of This
+Mod if you modify, extend, rename, remove, or in any other way alter any part
+of the public API code, save data formats, or network protocols in
+such a way that it is not perfectly compatible with the official versions of
+This Mod.
+
+If you wish to make modifications to the previously mentioned features, you must
+contribute those modifications back to the maintainers of the official versions
+of This Mod, and once those changes have been integrated and published in an
+official release, your modified version is once again covered by the terms of
+section B.
+
+D. Protections and Abandonment.
+
+To avoid upstream API changes triggering violations of Section C, these
+permissions are valid as long as your modified version of This Mod is perfectly
+compatible with any current or past public release of the official versions of
+This Mod.
+
+In case the official version of This Mod has been completely abandoned by
+the maintainer(s) for 1 whole year with no intent of future updates given
+by said maintainers, modified versions of This Mod may be freely re-licensed
+to the GNU Lesser General Public License (LGPL), version 3.0 or later,
+without any of the additional terms imposed by the
+GNU Affero General Public License.
+-------------------------------------------------------------------------------
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

build.gradle.kts

@@ -0,0 +1,59 @@
+plugins {
+    id("fpgradle-minecraft") version("0.8.3")
+}
+
+group = "com.falsepattern"
+
+minecraft_fp {
+    mod {
+        modid = "chunkapi"
+        name = "ChunkAPI"
+        rootPkg = "$group.chunk"
+    }
+
+    api {
+        packages = listOf("api")
+    }
+
+    mixin {
+        pkg = "internal.mixin.mixins"
+        pluginClass = "internal.mixin.plugin.MixinPlugin"
+    }
+
+    core {
+        coreModClass = "internal.core.CoreLoadingPlugin"
+        accessTransformerFile = "chunkapi_at.cfg"
+    }
+
+    tokens {
+        tokenClass = "internal.Tags"
+    }
+
+    publish {
+        changelog = "https://github.com/FalsePattern/ChunkAPI/releases/tag/$version"
+        maven {
+            repoUrl = "https://mvn.falsepattern.com/releases/"
+            repoName = "mavenpattern"
+        }
+        curseforge {
+            projectId = "844484"
+            dependencies {
+                required("fplib")
+            }
+        }
+        modrinth {
+            projectId = "y0vBUOla"
+            dependencies {
+                required("fplib")
+            }
+        }
+    }
+}
+
+repositories {
+    exclusive(maven("mavenpattern", "https://mvn.falsepattern.com/releases/"), "com.falsepattern")
+}
+
+dependencies {
+    apiSplit("com.falsepattern:falsepatternlib-mc1.7.10:1.5.4")
+}

dependencies.gradle

@@ -1,11 +0,0 @@
-dependencies {
-    compileOnly("org.projectlombok:lombok:[1.18.24,1.19)") {
-        transitive = false
-    }
-    annotationProcessor("org.projectlombok:lombok:[1.18.24,1.19)")
-
-    implementation("com.falsepattern:falsepatternlib-mc1.7.10:[0.10.15,0.11):dev")
-
-    compileOnly("org.jetbrains:annotations:[24,25)")
-
-}

gradle.properties

@@ -1,214 +0,0 @@
-# Mod settings
-#region mod
-
-modName = ChunkAPI
-
-# This is a case-sensitive string to identify your mod. Convention is to use lower case.
-modId = chunkapi
-
-# The "root package" of your mod. All of your mod classes *should* be placed under this package for simplicity.
-modGroup = com.falsepattern.chunk
-
-# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise, you can
-# leave this property empty.
-# Example value: apiPackage = api + modGroup = com.falsepattern.chunk -> com.falsepattern.chunk.api
-apiPackage = api
-
-# WHY is there no version field?
-# The build script relies on git to provide a version via tags. It is super easy and will enable you to always know the
-# code base or your binary. Check out this tutorial: https://blog.mattclemente.com/2017/10/13/versioning-with-git-tags/
-# However, if you really want to, you can use the VERSION environment variable to override this.
-
-minecraftVersion = 1.7.10
-forgeVersion = 10.13.4.1614
-
-# Select a username for testing your mod with breakpoints. You may leave this empty for a random username each time you
-# restart Minecraft in development. Choose this dependent on your mod:
-# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
-# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
-developmentEnvironmentUserName = Developer
-
-#endregion mod
-
-# Publishing settings
-#region publishing
-
-# Note: Both the modrinth and the curseforge publications are invoked by the "publish" gradle task
-# (when the respective publication's project ID is set up correctly, of course). You don't need to individually run
-# each of them.
-
-# Maven publishing
-#region maven
-
-# The maven server to upload the artifacts to
-repositoryURL = https://mvn.falsepattern.com/releases/
-
-# What name is the login information inside ~/.m2/settings.xml stored under
-# (see https://gist.github.com/FalsePattern/82d93e3cfab01f671cc5f4a95931cfe3 for an example)
-# You can also use the MAVEN_DEPLOY_USER and MAVEN_DEPLOY_PASSWORD environment variables to set this information!
-repositoryName = mavenpattern
-
-# What the artifact should be called. These will be the "name" of the published package, suffixed with the minecraft
-# version with a -mc prefix (groupid:artifactid-mcminecraftVersion:version:qualifier).
-# For instance, the default values this example ships with would turn into com.falsepattern:mymodid-mc1.7.10:version
-# The version is determined automatically from the git version.
-mavenGroupId = com.falsepattern
-mavenArtifactId = chunkapi
-
-#endregion maven
-
-# Modrinth publishing
-#region modrinth
-
-# Publishing to modrinth requires you to set the MODRINTH_TOKEN environment variable to your current modrinth API token.
-
-# The project's ID on Modrinth. Can be either the slug or the ID.
-# Leave this empty if you don't want to publish on Modrinth.
-modrinthProjectId = y0vBUOla
-
-# The project's dependencies on Modrinth. You can use this to refer to other projects on Modrinth.
-# Syntax: scope1-type1:name1;scope2-type2:name2;...
-# Where scope can be one of [required, optional, incompatible, embedded],
-#       type can be one of [project, version],
-#       and the name is the Modrinth project or version slug/id of the other mod.
-# Example: required-project:fplib;incompatible-project:gregtech
-# Note: GasStation is automatically set as a required dependency if usesMixins = true
-modrinthDependencies = required-project:fplib
-
-#endregion modrinth
-
-# CurseForge publishing
-#region curseforge
-
-# Publishing to CurseForge requires you to set the CURSEFORGE_TOKEN environment variable to one of your CurseForge API tokens.
-
-# The project's numeric ID on CurseForge. You can find this in the About Project box.
-# Leave this empty if you don't want to publish on CurseForge.
-curseForgeProjectId = 844484
-
-# The project's relations on CurseForge. You can use this to refer to other projects on CurseForge.
-# Syntax: type1:name1;type2:name2;...
-# Where type can be one of [requiredDependency, embeddedLibrary, optionalDependency, tool, incompatible],
-#       and the name is the CurseForge project id of the other mod.
-# Example: requiredDependency:railcraft;embeddedLibrary:cofhlib;incompatible:buildcraft
-# Note: GasStation is automatically set as a required dependency if usesMixins = true
-curseForgeRelations = requiredDependency:fplib
-
-#endregion curseforge
-
-# This will be inserted as the changelog text in the Modrinth/CurseForge publications.
-# If the text contains "{version}", it will be replaced with the current mod version. This is useful when the changelog
-# is just a URL pointing to a GitHub release tag.
-# If left empty, the changelog will be attempted to be read from the file at the CHANGELOG_FILE environment variable,
-# or the CHANGELOG.md file in the project root if the variable is not set.
-# If neither this property, nor the file, nor the environment variable (or the file it points to) exist, the changelog
-# will be set to "No changelog was provided.".
-# Example: https://github.com/myname/mymod/releases/tag/{version}
-changelog =
-
-# endregion publishing
-
-# Buildscript automatic update checker settings
-#region autoupdates
-
-# Will update your build.gradle automatically whenever an update is available
-autoUpdateBuildScript = false
-# Disable checking of buildscript updates.
-skipBuildScriptUpdateCheck = false
-
-#endregion autoupdates
-
-# Gradle token strings
-#region gradletokens
-
-# Define a source file of your project with:
-# public static final String VERSION = "GRADLETOKEN_VERSION";
-# The string's content will be replaced with your mods version when compiled. You should use this to specify your mod's
-# version in @Mod([...], version = VERSION, [...])
-# Leave these properties empty to skip individual token replacements
-# Multiple source files can be defined here by providing a comma-seperated list: Class1.java,Class2.java,Class3.java
-replaceGradleTokenInFile = Tags.java
-gradleTokenModId = GRADLETOKEN_MODID
-gradleTokenModName = GRADLETOKEN_MODNAME
-gradleTokenVersion = GRADLETOKEN_VERSION
-gradleTokenGroupName = GRADLETOKEN_GROUPNAME
-
-#endregion gradletokens
-
-# Mixins
-#region mixins
-
-# Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled!
-# When this is enabled, the mixinPlugin, mixinPluginPreInit, mixinsPackage, and mixinConfigs properties become active.
-usesMixins = true
-# Enable this if one of the dependencies uses mixins. Note: if usesMixins is true, this property is ignored. Only use this
-# if a dependency requires mixins BUT this mod doesn't.
-hasMixinDeps = false
-# Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
-mixinPlugin = internal.mixin.plugin.MixinPlugin
-# Whether you want the plugin to be configured as a PREINIT mixin
-mixinPluginPreInit = false
-# The minimum SpongePowered Mixins version required by the plugin. Internal default is 0.8.5 (GasStation)
-mixinPluginMinimumVersion =
-# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
-mixinsPackage = internal.mixin.mixins
-# Specify any custom mixin .json configs here. If you have multiple, comma-separate them. If you don't want to load
-# any jsons manually, leave this empty. You can use custom configs even if you already have a plugin added.
-# note: mixins.<modid>.json is used by the mixinPlugin's autogenerated config. Additionally, the refmap from the mixinsPackage
-# is always put into mixins.<modid>.refmap.json.
-# example: mixins.foo.json,mixins.bar.json
-mixinConfigs =
-
-#endregion mixins
-
-# Coremod and access transformers
-#region core
-
-# Specify the configuration file for Forge's access transformers here. I must be placed into /src/main/resources/META-INF/
-# Example value: mymodid_at.cfg
-accessTransformersFile =
-
-# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
-# This parameter is for legacy compatibility only
-# Example value: coreModClass = asm.FMLPlugin + modGroup = com.falsepattern.chunk -> com.falsepattern.chunk.asm.FMLPlugin
-coreModClass =
-
-#endregion core
-
-# Dependency deobfuscation settings (advanced)
-#region ddeobf
-
-# These 3 entries specify the location where the SRG mappings should be fetched from. Only set these if you know
-# what you're doing. The defaults inside the buildscript should just work without any extra configuration.
-remoteMappings =
-mappingsChannel =
-mappingsVersion =
-
-#endregion ddeobf
-
-# Miscellaneous settings
-#region misc
-
-# If your project is only a consolidation of mixins or a core mod and does NOT contain a 'normal' mod ( = some class
-# that is annotated with @Mod) you want this to be true. When in doubt: leave it on false!
-containsMixinsAndOrCoreModOnly = false
-
-# If enabled, you may use 'shadowCompile' for dependencies. They will be integrated in your jar. It is your
-# responsibility check the licence and request permission for distribution, if required.
-usesShadowedDependencies = false
-
-# If enabled, class stubbing will be enabled. In this mode, all classes with a package named "stubpackage" in their
-# path will be removed, and all classes that refer to said classes will be modified so that the "stubpackage" will map
-# to the root package instead. This is useful for referring to compile-time inaccessible classes, such as classes in the
-# default package
-remapStubs = true
-
-# Set this to true if you want to publish a proprietary mod without visible source code.
-#noPublishedSources =
-
-# Optional parameter to customize the produced artifacts. Use this to preserver artifact naming when migrating older
-# projects. New projects should not use this parameter.
-#customArchiveBaseName =
-
-#endregion misc
-

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,80 +15,116 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -97,92 +133,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
 fi
 
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -13,8 +13,10 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,10 +27,14 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
@@ -37,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -51,48 +57,36 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

readme.md

@@ -1,14 +1,29 @@
 # ChunkAPI
-
+<a rel="license" href="https://www.gnu.org/licenses/agpl-3.0.en.html"><img alt="AGPLv3 logo" style="border-width:0" src="https://www.gnu.org/graphics/agplv3-with-text-162x68.png" /></a>
 ## Author: FalsePattern
-## License: No derivatives visible-source with API exception. See the LICENSE file for more details.
-
+## License: GNU AGPLv3.0 with additional permissions (see below, or in the LICENSE file)
 
 Summary
 -------
 
 A mod for adding custom data to chunks without the hassle of writing custom packets, event handling, loading hooks, and more.
 
+License
+-------
+
+ChunkAPI is designed with players in mind, and as such, it uses slightly aggressive licensing to make sure that third
+party developers cannot break your worlds in an irrecoverable way by changing huge parts of the API.
+
+For this reason, the mod itself is fully licensed under the GNU Affero General Public License, version 3.0 or later,
+with several additional permissions according to Section 7 of the AGPL.
+
+You can find these permissions in the full [LICENSE](LICENSE) file. (TL;DR: Yes, you can use official releases of
+ChunkAPI in a modpack without getting trapped by AGPL's requirements).
+
+Note that while these limitations might seem unnecessary, it is essential for protecting your saves from getting
+"trapped" in a random fork of ChunkAPI without any way to recover to vanilla or the official release of ChunkAPI
+without world corruption, in case no suitable backups are available.
+
 Goals
 -----
 
@@ -33,7 +48,7 @@ Modifying chunk packet data involved incompatibly modifying network packets, the
 which is a lot of work for a simple feature. This mod provides a way to add custom data to chunks without having
 to modify any of the vanilla classes yourself.
 
-Description
+API and spec
 -----------
 
 The API exposes a way to add custom data to chunks, and a way to register custom serializers for the data.
@@ -61,27 +76,54 @@ This is where you actually register your manager. You need to do all registratio
 You can also disable specific manager IDs by calling `disableDataManager`, but this is not recommended, and should
 only be used if you know what you are doing. You need to do all the disabling inside the `postInit` phase.
 
-Alternatives
-------------
+### Packet specification
 
-Mods can also implement their own chunk-independent data storage, or even use hidden entities to store data, but
-this is not a good solution and prone to breaking.
+ChunkAPI modifies the S21PacketChunkData and S26PacketMapChunkBulk vanilla packets, and overwrites their default
+formats.
 
-Testing
--------
+All sizes in the tables below are specified in bytes.
 
-This mod will be tested by using it in my own mods, primarily EndlessIDs.
+S21PacketChunkData new format:
 
-Risks and Assumptions
----------------------
+| Size (bytes) | Datatype | Name                       |
+|--------------|----------|----------------------------|
+| 4            | int      | X position                 |
+| 4            | int      | Z position                 |
+| 1            | bool     | Force Update               |
+| 2            | short    | ExtendedBlockStorage mask  |
+| 4            | int      | Uncompressed data length   |
+| 4            | int      | (n) Compressed data length |
+| n            | byte[n]  | Compressed data            |
+
+S26PacketMapChunkBulk new format:
+
+| Size (bytes) | Datatype             | Name                            |
+|--------------|----------------------|---------------------------------|
+| 2            | short                | (n) Chunk count in packet       |
+| n * 4        | int[n]               | Uncompressed chunk data lengths |
+| 4            | int                  | (m) Compressed data length      |
+| 1            | 1                    | Contains skylight data          |
+| m            | byte[m]              | Compressed data                 |
+| n * 10       | (int, int, short)[n] | Chunk Headers (x, z, ebs mask)  |
+
+In both cases, the compressed data is populated through the ChunkDataRegistryImpl.writeToBuffer method.
+The layout of this data is as follows:
+
+| Size (bytes) | Datatype | Name              |
+|--------------|----------|-------------------|
+| 4            | int      | (n) Manager count |
+| n * varying  | MGRData  | Manager data      |
+
+Manager data:
+
+| Size (bytes) | Datatype  | Name                    |
+|--------------|-----------|-------------------------|
+| 4            | int       | (n) Manager name length |
+| n            | UTF-8 str | Manager name            |
+| 4            | int       | (m) Manager data length |
+| m            | byte[m]   | Manager data            |
 
-This might slow down chunk loading/saving, and the networking, if the implementation turns out to be bad.
-Ideally, mods should declare their custom data as new fields in the chunk class using mixins instead of the
-ModdedChunk storage, but this is not a requirement.
 
-Ideally, this project must not have any derivatives or forks, as that will counter the primary purpose of this project,
-which is a single, unified codebase for chunk data exchange. For that goal, the project is explicitly licensed such as
-no derivatives are permitted.
 
 Dependencies
 ------------

repositories.gradle

@@ -1,6 +0,0 @@
-repositories {
-    maven {
-        name = "mvnpattern"
-        url = "https://mvn.falsepattern.com/releases"
-    }
-}

settings.gradle.kts

@@ -0,0 +1,35 @@
+pluginManagement {
+    repositories {
+        maven {
+            url = uri("https://mvn.falsepattern.com/fpgradle/")
+            name = "fpgradle"
+            content {
+                includeModule("com.gtnewhorizons", "retrofuturagradle")
+                includeModule("com.falsepattern", "fpgradle-plugin")
+                includeModule("fpgradle-minecraft", "fpgradle-minecraft.gradle.plugin")
+            }
+        }
+        maven {
+            url = uri("https://mvn.falsepattern.com/releases/")
+            name = "mavenpattern"
+            content {
+                includeGroup("com.falsepattern")
+            }
+        }
+        maven {
+            url = uri("https://mvn.falsepattern.com/jitpack/")
+            name = "jitpack"
+            content {
+                includeModule("io.github.LegacyModdingMC.MappingGenerator", "MappingGenerator")
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
+}
+
+rootProject.name = "ChunkAPI"

src/main/java/com/falsepattern/chunk/api/ArrayUtil.java

@@ -0,0 +1,177 @@
+/*
+ * ChunkAPI
+ *
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
+ */
+
+package com.falsepattern.chunk.api;
+
+import com.falsepattern.lib.StableAPI;
+import org.jetbrains.annotations.Contract;
+
+import net.minecraft.world.chunk.NibbleArray;
+
+import java.util.Arrays;
+
+/**
+ * This is an API class covered by the additional permissions in the license.
+ * <p>
+ * Miscellaneous utilities for in-place array transfer (where possible).
+ */
+@StableAPI(since = "0.5.0")
+public class ArrayUtil {
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static boolean[] copyArray(boolean[] src, boolean[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static byte[] copyArray(byte[] src, byte[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static char[] copyArray(char[] src, char[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static short[] copyArray(short[] src, short[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static int[] copyArray(int[] src, int[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static long[] copyArray(long[] src, long[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static float[] copyArray(float[] src, float[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static double[] copyArray(double[] src, double[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static <T> T[] copyArray(T[] src, T[] dst) {
+        if (src == null)
+            return null;
+        if (dst == null || src.length != dst.length)
+            return Arrays.copyOf(src, src.length);
+        System.arraycopy(src, 0, dst, 0, src.length);
+        return dst;
+    }
+
+    @StableAPI.Expose
+    @Contract(value = "null, _ -> null;" +
+                      "!null, null -> new;",
+              mutates = "param2")
+    public static NibbleArray copyArray(NibbleArray srcArray, NibbleArray dstArray) {
+        if (srcArray == null) {
+            return null;
+        }
+        if (dstArray == null) {
+            return new NibbleArray(Arrays.copyOf(srcArray.data, srcArray.data.length), srcArray.depthBits);
+        }
+        dstArray.depthBits = srcArray.depthBits;
+        dstArray.depthBitsPlusFour = srcArray.depthBitsPlusFour;
+        dstArray.data = copyArray(srcArray.data, dstArray.data);
+        return dstArray;
+    }
+}

src/main/java/com/falsepattern/chunk/api/ChunkDataManager.java

@@ -1,170 +0,0 @@
-/*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
- *
- * Copyright 2023
- *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
- */
-
-package com.falsepattern.chunk.api;
-
-import com.falsepattern.lib.StableAPI;
-import org.jetbrains.annotations.Contract;
-
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
-
-import java.nio.ByteBuffer;
-
-/**
- * Singleton instances that can manage custom in chunks. This class only manages the registration of
- * managers. For the actual networking and data storage, see the internal interfaces of this interface.
- * Note: This interface does nothing by itself, you also need to implement one or more of the internal interfaces.
- *
- * @since 0.1.0
- * @see ChunkDataManager.PacketDataManager
- * @see ChunkDataManager.ChunkNBTDataManager
- * @see ChunkDataManager.SectionNBTDataManager
- * @see ChunkDataRegistry
- * @author FalsePattern
- * @version 0.1.0
- */
-@StableAPI(since = "0.1.0")
-public interface ChunkDataManager {
-
-    /**
-     * @return The domain of this manager. Usually the modid of the mod that owns this manager.
-     */
-    @StableAPI.Expose
-    @Contract(pure = true)
-    String domain();
-
-    /**
-     * @return The id of this manager. Usually the name of the manager. Unique per domain.
-     */
-    @StableAPI.Expose
-    @Contract(pure = true)
-    String id();
-
-    /**
-     * Implement this interface if you want to synchronize your data with the client.
-     *
-     * @since 0.1.0
-     * @author FalsePattern
-     * @version 0.1.0
-     */
-    @StableAPI(since = "0.1.0")
-    interface PacketDataManager extends ChunkDataManager {
-        /**
-         * @return The maximum amount of bytes your data can take up in a packet.
-         *
-         * @implNote This is used to determine the size of the packet compression/decompression buffer.
-         */
-        @StableAPI.Expose
-        @Contract(pure = true)
-        int maxPacketSize();
-
-        /**
-         * Serializes your data into a packet.
-         *
-         * @param chunk The chunk to serialize.
-         */
-        @StableAPI.Expose
-        void writeToBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer data);
-
-        /**
-         * Deserializes your data from a packet.
-         * Mutates this object.
-         *
-         * @param chunk  The chunk to deserialize.
-         * @param buffer The packet buffer to read from.
-         */
-        @StableAPI.Expose
-        void readFromBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer buffer);
-    }
-
-    /**
-     * Implement this interface if you want to save your data to disk. This is called once per chunk.
-     *
-     * @since 0.1.0
-     * @author FalsePattern
-     * @version 0.1.0
-     */
-    @StableAPI(since = "0.1.0")
-    interface ChunkNBTDataManager extends ChunkDataManager {
-        /**
-         * If false, the given nbt compound will be a freshly created object that gets inserted into the actual
-         * level NBT tag under the `domain:id` name.
-         * <p>
-         * If true, the nbt tag passed in into the write/read methods will be the raw Level NBT tag without filtering.
-         *
-         * @implNote This is used internally for reimplementing the vanilla logic. Only change this if you know what you're doing.
-         */
-        @StableAPI.Expose
-        @Contract(pure = true)
-        default boolean chunkPrivilegedAccess() {
-            return false;
-        }
-
-        /**
-         * Serializes your data into an NBT tag. This is used when saving the chunk to disk.
-         */
-        @StableAPI.Expose
-        void writeChunkToNBT(Chunk chunk, NBTTagCompound nbt);
-
-
-        /**
-         * Deserializes your data from an NBT tag. This is used when loading the chunk from disk.
-         * The NBT *may* be null if the chunk was saved before this manager was registered
-         * (e.g., loading save before the mod was added), and the manager is not {@link #chunkPrivilegedAccess() privileged}.
-         * In this case, you should initialize the data to a sane default.
-         */
-        @StableAPI.Expose
-        void readChunkFromNBT(Chunk chunk, NBTTagCompound nbt);
-    }
-
-    /**
-     * Implement this interface if you want to save your ExtendedBlockStorage data to disk. This is called once per
-     * ExtendedBlockStorage per chunk. (16 times per chunk)
-     *
-     * @since 0.1.0
-     * @author FalsePattern
-     * @version 0.1.0
-     */
-    @StableAPI(since = "0.1.0")
-    interface SectionNBTDataManager extends ChunkDataManager {
-        /**
-         * If false, the given nbt compound will be a freshly created object that gets inserted into the actual
-         * segment NBT tag under the `domain:id` name.
-         * <p>
-         * If true, the nbt tag passed in into the write/read methods will be the raw segment NBT tag without filtering.
-         *
-         * @implNote This is used internally for reimplementing the vanilla logic. Only change this if you know what you're doing.
-         */
-        @StableAPI.Expose
-        @Contract(pure = true)
-        default boolean sectionPrivilegedAccess() {
-            return false;
-        }
-
-        /**
-         * Serializes your data into an NBT tag. This is used when saving the chunk to disk.
-         */
-        @StableAPI.Expose
-        void writeSectionToNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section);
-
-        /**
-         * Deserializes your data from an NBT tag. This is used when loading the chunk from disk.
-         * The NBT *may* be null if the chunk was saved before this manager was registered
-         * (e.g., loading save before the mod was added), and the manager is not {@link #sectionPrivilegedAccess() privileged}.
-         * In this case, you should initialize the data to a sane default.
-         */
-        @StableAPI.Expose
-        void readSectionFromNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section);
-    }
-}

src/main/java/com/falsepattern/chunk/api/ChunkDataRegistry.java

@@ -1,64 +0,0 @@
-/*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
- *
- * Copyright 2023
- *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
- */
-
-package com.falsepattern.chunk.api;
-
-import com.falsepattern.chunk.internal.ChunkDataRegistryImpl;
-import com.falsepattern.lib.StableAPI;
-
-import java.util.Set;
-
-/**
- * This class is used to register ChunkDataManagers.
- *
- * @since 0.1.0
- * @see ChunkDataManager
- * @author FalsePattern
- * @version 0.1.0
- */
-@StableAPI(since = "0.1.0")
-public class ChunkDataRegistry {
-    /**
-     * Registers a ChunkDataManager. Only do this during the preInit phase.
-     *
-     * @param manager The manager to register.
-     *
-     * @throws IllegalStateException    If the registration stage is over.
-     * @throws IllegalArgumentException If the manager has a duplicate id.
-     */
-    @StableAPI.Expose
-    public static void registerDataManager(ChunkDataManager manager)
-            throws IllegalStateException, IllegalArgumentException {
-        ChunkDataRegistryImpl.registerDataManager(manager);
-    }
-
-    /**
-     * Disables a ChunkDataManager. Only do this during the preInit phase.
-     *
-     * @param id The id of the manager to disable.
-     *
-     * @throws IllegalStateException If the disable stage is over.
-     */
-    @StableAPI.Expose
-    public static void disableDataManager(String domain, String id) throws IllegalStateException {
-        ChunkDataRegistryImpl.disableDataManager(domain, id);
-    }
-
-    /**
-     * Returns an unmodifiable set of all registered ChunkDataManagers.
-     * The id of a manager is its domain and id separated by a colon. (domain:id)
-     */
-    @StableAPI.Expose
-    public static Set<String> getRegisteredManagers() {
-        return ChunkDataRegistryImpl.getRegisteredManagers();
-    }
-}

src/main/java/com/falsepattern/chunk/api/DataManager.java

@@ -0,0 +1,295 @@
+/*
+ * ChunkAPI
+ *
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
+ */
+
+package com.falsepattern.chunk.api;
+
+import com.falsepattern.lib.StableAPI;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * This is an API class covered by the additional permissions in the license.
+ * <p>
+ * Singleton instances that can manage custom in chunks. This class only manages the registration of
+ * managers. For the actual networking and data storage, see the internal interfaces of this interface.
+ * Note: This interface does nothing by itself, you also need to implement one or more of the internal interfaces.
+ *
+ * @since 0.5.0
+ * @see PacketDataManager
+ * @see ChunkDataManager
+ * @see SubChunkDataManager
+ * @see DataRegistry
+ * @author FalsePattern
+ * @version 0.5.0
+ */
+@StableAPI(since = "0.5.0")
+public interface DataManager {
+
+    /**
+     * @return The domain of this manager. Usually the modid of the mod that owns this manager.
+     */
+    @StableAPI.Expose
+    @Contract(pure = true)
+    String domain();
+
+    /**
+     * @return The id of this manager. Usually the name of the manager. Unique per domain.
+     */
+    @StableAPI.Expose
+    @Contract(pure = true)
+    String id();
+
+    /**
+     * Implement this interface if you want to synchronize your data with the client.
+     *
+     * @since 0.5.0
+     * @author FalsePattern
+     * @version 0.5.0
+     */
+    @StableAPI(since = "0.5.0")
+    interface PacketDataManager extends DataManager {
+        /**
+         * @return The maximum amount of bytes your data can take up in a packet.
+         *
+         * @implSpec This is used to determine the size of the packet compression/decompression buffer.
+         * Only called ONCE, during registration!
+         */
+        @StableAPI.Expose
+        @Contract(pure = true)
+        int maxPacketSize();
+
+        /**
+         * Serializes your data into a packet.
+         *
+         * @param chunk The chunk to serialize.
+         */
+        @Contract(mutates = "param4")
+        @StableAPI.Expose
+        void writeToBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer);
+
+        /**
+         * Deserializes your data from a packet.
+         *
+         * @param chunk  The chunk to deserialize.
+         * @param buffer The packet buffer to read from.
+         */
+        @Contract(mutates = "param1,param4")
+        @StableAPI.Expose
+        void readFromBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer);
+    }
+
+    /**
+     * Implement this interface if you additionally want to synchronize your data on single and multi-block updates,
+     * not just chunk updates.
+     *
+     * @since 0.6.0
+     * @author FalsePattern
+     * @version 0.6.0
+     */
+    @StableAPI(since = "0.6.0")
+    interface BlockPacketDataManager extends DataManager {
+        @Contract(mutates = "param1")
+        @StableAPI.Expose
+        void writeBlockToPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet);
+
+        @Contract(mutates = "param1,param5")
+        @StableAPI.Expose
+        void readBlockFromPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet);
+
+        /**
+         * Serializes your block data into a buffer.
+         */
+        @Contract(mutates = "param2")
+        @StableAPI.Expose
+        void writeBlockPacketToBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException;
+
+        /**
+         * Deserializes your block data from a buffer.
+         */
+        @Contract(mutates = "param1,param2")
+        @StableAPI.Expose
+        void readBlockPacketFromBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException;
+    }
+
+    /**
+     * The common superinterface for RootDataManager and SubChunkDataManager.
+     * Contains version information and messages for users attempting to upgrade/remove versions.
+     * @since 0.5.0
+     * @author FalsePattern
+     * @version 0.5.0
+     */
+    @StableAPI(since = "0.5.0")
+    interface StorageDataManager extends DataManager {
+        /**
+         * @return The current version of the data manager
+         */
+        @StableAPI.Expose
+        @Contract(pure = true)
+        @NotNull
+        String version();
+
+        /**
+         * @return The message to show to users when a world is opened with this mod for the first time.
+         *         Return null to show no message, and treat the manager as fully compatible with vanilla.
+         */
+        @StableAPI.Expose
+        @Contract(pure = true)
+        @Nullable
+        String newInstallDescription();
+
+        /**
+         * @return The message to show to users when this manager is removed, AND they try to load the world (stored in the
+         * world's NBT during previous saves)
+         */
+        @StableAPI.Expose
+        @Contract(pure = true)
+        @NotNull
+        String uninstallMessage();
+
+        /**
+         * @param priorVersion The version of the manager this world was saved with.
+         * @return A warning message to show to the user when upgrading.\
+         *         If null, the manager is treated as fully compatible with the old version, and no warning is shown.
+         */
+        @StableAPI.Expose
+        @Contract(pure = true)
+        @Nullable
+        String versionChangeMessage(String priorVersion);
+    }
+
+    /**
+     * Implement this interface if you want to save your data to disk. This is called once per chunk, hence "root"
+     *
+     * @since 0.5.0
+     * @author FalsePattern
+     * @version 0.5.0
+     */
+    @StableAPI(since = "0.5.0")
+    interface ChunkDataManager extends StorageDataManager {
+        /**
+         * If false, the given nbt compound will be a freshly created object that gets inserted into the actual
+         * level NBT tag under the `domain:id` name.
+         * <p>
+         * If true, the nbt tag passed in into the write/read methods will be the raw Level NBT tag without filtering.
+         *
+         * @implNote This is used internally for reimplementing the vanilla logic. Only change this if you know what you're doing.
+         */
+        @StableAPI.Expose
+        @Contract(pure = true)
+        default boolean chunkPrivilegedAccess() {
+            return false;
+        }
+
+        /**
+         * Serializes your data into an NBT tag. This is used when saving the chunk to disk.
+         */
+        @Contract(mutates = "param2")
+        @StableAPI.Expose
+        void writeChunkToNBT(Chunk chunk, NBTTagCompound nbt);
+
+
+        /**
+         * Deserializes your data from an NBT tag. This is used when loading the chunk from disk.
+         * The NBT *may* be null if the chunk was saved before this manager was registered
+         * (e.g., loading save before the mod was added), and the manager is not {@link #chunkPrivilegedAccess() privileged}.
+         * In this case, you should initialize the data to a sane default.
+         */
+        @Contract(mutates = "param1")
+        @StableAPI.Expose
+        void readChunkFromNBT(Chunk chunk, NBTTagCompound nbt);
+
+        /**
+         * Directly copies data from one chunk to another chunk.
+         * @param from The chunk to copy data from.
+         * @param to The chunk to copy data to.
+         */
+        @Contract(mutates = "param2")
+        @StableAPI.Expose
+        void cloneChunk(Chunk from, Chunk to);
+    }
+
+    /**
+     * Implement this interface if you want to save your subChunk data to disk. This is called once per
+     * ExtendedBlockStorage per chunk. (16 times per chunk)
+     *
+     * @since 0.5.0
+     * @author FalsePattern
+     * @version 0.5.0
+     */
+    @StableAPI(since = "0.5.0")
+    interface SubChunkDataManager extends StorageDataManager {
+        /**
+         * If false, the given nbt compound will be a freshly created object that gets inserted into the actual
+         * segment NBT tag under the `domain:id` name.
+         * <p>
+         * If true, the nbt tag passed in into the write/read methods will be the raw segment NBT tag without filtering.
+         *
+         * @implNote This is used internally for reimplementing the vanilla logic. Only change this if you know what you're doing.
+         */
+        @StableAPI.Expose
+        @Contract(pure = true)
+        default boolean subChunkPrivilegedAccess() {
+            return false;
+        }
+
+        /**
+         * Serializes your data into an NBT tag. This is used when saving the chunk to disk.
+         */
+        @Contract(mutates = "param3")
+        @StableAPI.Expose
+        void writeSubChunkToNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt);
+
+        /**
+         * Deserializes your data from an NBT tag. This is used when loading the chunk from disk.
+         * The NBT *may* be null if the chunk was saved before this manager was registered
+         * (e.g., loading save before the mod was added), and the manager is not {@link #subChunkPrivilegedAccess() privileged}.
+         * In this case, you should initialize the data to a sane default.
+         */
+        @Contract(mutates = "param2")
+        @StableAPI.Expose
+        void readSubChunkFromNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt);
+
+        /**
+         * Directly copies data from one subChunk to another.
+         * @param fromChunk The owner of the subChunk to copy data from.
+         * @param from The subChunk to copy data from.
+         * @param to The subChunk to copy data to.
+         */
+        @Contract(mutates = "param3")
+        @StableAPI.Expose
+        void cloneSubChunk(Chunk fromChunk, ExtendedBlockStorage from, ExtendedBlockStorage to);
+    }
+}

src/main/java/com/falsepattern/chunk/api/DataRegistry.java

@@ -0,0 +1,110 @@
+/*
+ * ChunkAPI
+ *
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
+ */
+
+package com.falsepattern.chunk.api;
+
+import com.falsepattern.chunk.internal.DataRegistryImpl;
+import com.falsepattern.lib.StableAPI;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+
+import java.util.Set;
+
+/**
+ * This is an API class covered by the additional permissions in the license.
+ * <p>
+ * This class is used to register ChunkDataManagers, as well as dispatch clone requests.
+ *
+ * @since 0.5.0
+ * @see DataManager
+ * @author FalsePattern
+ * @version 0.5.0
+ */
+@StableAPI(since = "0.5.0")
+public class DataRegistry {
+    /**
+     * Registers a ChunkDataManager. Only do this during the init phase.
+     *
+     * @param manager The manager to register.
+     *
+     * @throws IllegalStateException    If the registration stage is over.
+     * @throws IllegalArgumentException If the manager has a duplicate id.
+     */
+    @StableAPI.Expose
+    public static void registerDataManager(DataManager manager)
+            throws IllegalStateException, IllegalArgumentException {
+        DataRegistryImpl.registerDataManager(manager);
+    }
+
+    /**
+     * Disables a ChunkDataManager. Only do this during the postInit phase.
+     *
+     * @param id The id of the manager to disable.
+     *
+     * @throws IllegalStateException If the disable stage is over.
+     */
+    @StableAPI.Expose
+    public static void disableDataManager(String domain, String id) throws IllegalStateException {
+        DataRegistryImpl.disableDataManager(domain, id);
+    }
+
+    /**
+     * Returns an unmodifiable set of all registered ChunkDataManagers.
+     * The id of a manager is its domain and id separated by a colon. (domain:id)
+     */
+    @Contract(pure = true)
+    @StableAPI.Expose
+    public static @Unmodifiable Set<String> getRegisteredManagers() {
+        return DataRegistryImpl.getRegisteredManagers();
+    }
+
+    /**
+     * Copies chunk-level data from a source chunk to a target chunk.
+     * DOES NOT copy data contained inside its ExtendedBlockStorage instances!!
+     * @param from The chunk to read the data from
+     * @param to The chunk to write the data to
+     */
+    @Contract(mutates = "param2")
+    @StableAPI.Expose(since = "0.5.0")
+    public static void cloneChunk(Chunk from, Chunk to) {
+        DataRegistryImpl.cloneChunk(from, to);
+    }
+
+    /**
+     * Copies data from a source subChunk to a target subChunk.
+     * @param fromChunk The chunk that owns the *from* subChunk. Used by data managers for getting metadata about the world (skylight presence, etc.)
+     * @param from The subChunk to read the data from
+     * @param to The subChunk to write the data to
+     */
+    @Contract(mutates = "param3")
+    @StableAPI.Expose(since = "0.5.0")
+    public static void cloneSubChunk(Chunk fromChunk, ExtendedBlockStorage from, ExtendedBlockStorage to) {
+        DataRegistryImpl.cloneSubChunk(fromChunk, from, to);
+    }
+}

src/main/java/com/falsepattern/chunk/api/package-info.java

@@ -1,20 +1,36 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 /**
+ * This is an API package covered by the additional permissions in the license.
+ * <p>
  * This package contains the classes that you will use to interact with the ChunkAPI library.
  *
- * @since 0.1.0
+ * @since 0.5.0
  * @author FalsePattern
- * @version 0.1.0
+ * @version 0.5.0
  */
 package com.falsepattern.chunk.api;

src/main/java/com/falsepattern/chunk/internal/BlockPosUtil.java

@@ -0,0 +1,28 @@
+package com.falsepattern.chunk.internal;
+
+public class BlockPosUtil {
+    private static final int NUM_X_BITS = 26;
+    private static final int NUM_Z_BITS = 26;
+    private static final int NUM_Y_BITS = 64 - NUM_X_BITS - NUM_Z_BITS;
+    private static final long Y_MASK = (1L << NUM_Y_BITS) - 1L;
+    private static final int Y_SHIFT = NUM_Z_BITS;
+    private static final int X_SHIFT = Y_SHIFT + NUM_Y_BITS;
+    private static final long Z_MASK = (1L << NUM_Z_BITS) - 1L;
+    private static final long X_MASK = (1L << NUM_X_BITS) - 1L;
+
+    public static long packToLong(int x, int y, int z) {
+        return ((long) x & X_MASK) << X_SHIFT | ((long) y & Y_MASK) << Y_SHIFT | ((long) z & Z_MASK);
+    }
+
+    public static int getX(long packed) {
+        return (int) (packed << 64 - X_SHIFT - NUM_X_BITS >> 64 - NUM_X_BITS);
+    }
+
+    public static int getY(long packed) {
+        return (int) (packed << 64 - Y_SHIFT - NUM_Y_BITS >> 64 - NUM_Y_BITS);
+    }
+
+    public static int getZ(long packed) {
+        return (int) (packed << 64 - NUM_Z_BITS >> 64 - NUM_Z_BITS);
+    }
+}

src/main/java/com/falsepattern/chunk/internal/ChunkAPI.java

@@ -1,40 +1,56 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal;
 
-import com.falsepattern.chunk.api.ChunkDataRegistry;
+import com.falsepattern.chunk.api.DataRegistry;
 import com.falsepattern.chunk.internal.vanilla.BiomeManager;
 import com.falsepattern.chunk.internal.vanilla.BlockIDManager;
 import com.falsepattern.chunk.internal.vanilla.BlocklightManager;
+import com.falsepattern.chunk.internal.vanilla.LightingManager;
 import com.falsepattern.chunk.internal.vanilla.MetadataManager;
 import com.falsepattern.chunk.internal.vanilla.SkylightManager;
 
 import cpw.mods.fml.common.Mod;
 import cpw.mods.fml.common.event.FMLInitializationEvent;
 
-@Mod(modid = Tags.MODID,
-     version = Tags.VERSION,
-     name = Tags.MODNAME,
+@Mod(modid = Tags.MOD_ID,
+     version = Tags.MOD_VERSION,
+     name = Tags.MOD_NAME,
      acceptedMinecraftVersions = "[1.7.10]",
-     dependencies = "required-after:falsepatternlib@[0.10.15,);")
+     dependencies = "required-after:falsepatternlib@[1.5.4,);")
 public class ChunkAPI {
 
     @Mod.EventHandler
     public void init(FMLInitializationEvent event) {
-        ChunkDataRegistry.registerDataManager(new BlockIDManager());
-        ChunkDataRegistry.registerDataManager(new MetadataManager());
-        ChunkDataRegistry.registerDataManager(new BlocklightManager());
-        ChunkDataRegistry.registerDataManager(new SkylightManager());
-        ChunkDataRegistry.registerDataManager(new BiomeManager());
+        DataRegistry.registerDataManager(new BlockIDManager());
+        DataRegistry.registerDataManager(new MetadataManager());
+        DataRegistry.registerDataManager(new LightingManager());
+        DataRegistry.registerDataManager(new BlocklightManager());
+        DataRegistry.registerDataManager(new SkylightManager());
+        DataRegistry.registerDataManager(new BiomeManager());
     }
 }

src/main/java/com/falsepattern/chunk/internal/ChunkDataRegistryImpl.java

@@ -1,224 +0,0 @@
-/*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
- *
- * Copyright 2023
- *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
- */
-
-package com.falsepattern.chunk.internal;
-
-import com.falsepattern.chunk.api.ChunkDataManager;
-import lombok.val;
-import lombok.var;
-
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
-import cpw.mods.fml.common.Loader;
-import cpw.mods.fml.common.LoaderState;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.charset.StandardCharsets;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-public class ChunkDataRegistryImpl {
-    private static final Set<String> managers = new HashSet<>();
-    private static final Map<String, ChunkDataManager.PacketDataManager> packetManagers = new HashMap<>();
-    private static final Map<String, ChunkDataManager.ChunkNBTDataManager> chunkNBTManagers = new HashMap<>();
-    private static final Map<String, ChunkDataManager.SectionNBTDataManager> sectionNBTManagers = new HashMap<>();
-    private static final Set<String> disabledManagers = new HashSet<>();
-    private static int maxPacketSize = 4;
-
-    public static void registerDataManager(ChunkDataManager manager)
-            throws IllegalStateException, IllegalArgumentException {
-        if (Loader.instance().getLoaderState() != LoaderState.INITIALIZATION) {
-            throw new IllegalStateException("ChunkDataManager registration is not allowed at this time! " +
-                                            "Please register your ChunkDataManager in the init phase.");
-        }
-        var id = manager.domain() + ":" + manager.id();
-        if (managers.contains(id)) {
-            throw new IllegalArgumentException("ChunkDataManager " + manager + " has a duplicate id!");
-        }
-
-        // If the manager was disabled, do not add it to the list of managers.
-        if (disabledManagers.contains(id)) {
-            return;
-        }
-
-        managers.add(id);
-        if (manager instanceof ChunkDataManager.PacketDataManager) {
-            val packetManager = (ChunkDataManager.PacketDataManager) manager;
-            maxPacketSize += 4 + id.getBytes(StandardCharsets.UTF_8).length;
-            maxPacketSize += packetManager.maxPacketSize();
-            packetManagers.put(id, packetManager);
-        }
-        if (manager instanceof ChunkDataManager.ChunkNBTDataManager) {
-            chunkNBTManagers.put(id, (ChunkDataManager.ChunkNBTDataManager) manager);
-        }
-        if (manager instanceof ChunkDataManager.SectionNBTDataManager) {
-            sectionNBTManagers.put(id, (ChunkDataManager.SectionNBTDataManager) manager);
-        }
-    }
-
-    public static void disableDataManager(String domain, String id) {
-        if (Loader.instance().getLoaderState() != LoaderState.POSTINITIALIZATION) {
-            throw new IllegalStateException("ChunkDataManager disabling is not allowed at this time! " +
-                                            "Please disable any ChunkDataManagers in the postInit phase.");
-        }
-        Common.LOG.warn("Disabling ChunkDataManager " + id + " in domain " + domain +
-                        ". See the stacktrace for the source of this event.", new Throwable());
-        val manager = domain + ":" + id;
-        //Remove the manager from the list of managers, if it exists
-        if (managers.remove(manager)) {
-            //Clear the maps
-            if (packetManagers.containsKey(manager)) {
-                val removed = packetManagers.remove(manager);
-                maxPacketSize -= 4 + manager.getBytes(StandardCharsets.UTF_8).length;
-                maxPacketSize -= removed.maxPacketSize();
-            }
-            chunkNBTManagers.remove(manager);
-            sectionNBTManagers.remove(manager);
-        }
-
-        //Add the manager to the list of disabled managers, in case it gets registered after this disable call.
-        disabledManagers.add(manager);
-    }
-
-    public static int maxPacketSize() {
-        return maxPacketSize;
-    }
-
-    private static void writeString(ByteBuffer buffer, String string) {
-        val bytes = string.getBytes();
-        buffer.putInt(bytes.length);
-        buffer.put(bytes);
-    }
-
-    private static String readString(ByteBuffer buffer) {
-        val length = buffer.getInt();
-        val bytes = new byte[length];
-        buffer.get(bytes);
-        return new String(bytes);
-    }
-
-    public static void readFromBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, byte[] data) {
-        val buf = ByteBuffer.wrap(data);
-        buf.order(ByteOrder.LITTLE_ENDIAN);
-        int count = buf.getInt();
-        for (int i = 0; i < count; i++) {
-            val id = readString(buf);
-            val length = buf.getInt();
-            val manager = packetManagers.get(id);
-            if (manager == null) {
-                Common.LOG.error("Received data for unknown PacketDataManager " + id + ". Skipping.");
-                buf.position(buf.position() + length);
-                continue;
-            }
-            int start = buf.position();
-            val slice = createSlice(buf, start, length);
-            manager.readFromBuffer(chunk, ebsMask, forceUpdate, slice);
-            buf.position(start + length);
-        }
-    }
-
-    public static int writeToBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, byte[] data) {
-        val buf = ByteBuffer.wrap(data);
-        buf.order(ByteOrder.LITTLE_ENDIAN);
-        buf.putInt(packetManagers.size());
-        for (val pair : packetManagers.entrySet()) {
-            val id = pair.getKey();
-            val manager = pair.getValue();
-            writeString(buf, id);
-            int start = buf.position() + 4;
-            val slice = createSlice(buf, start, manager.maxPacketSize());
-            manager.writeToBuffer(chunk, ebsMask, forceUpdate, slice);
-            int length = slice.position();
-            buf.putInt(length);
-            buf.position(start + length);
-        }
-        return buf.position();
-    }
-
-    private static ByteBuffer createSlice(ByteBuffer buffer, int start, int length) {
-        int oldLimit = buffer.limit();
-        int oldPosition = buffer.position();
-        buffer.position(start);
-        buffer.limit(start + length);
-        ByteBuffer slice = buffer.slice();
-        buffer.limit(oldLimit);
-        buffer.position(oldPosition);
-        return slice;
-    }
-
-    private static NBTTagCompound createManagerNBT(boolean privileged, NBTTagCompound root, ChunkDataManager manager) {
-        if (privileged) {
-            return root;
-        }
-        val domain = manager.domain();
-        NBTTagCompound domainNBT;
-        if (root.hasKey(domain)) {
-            domainNBT = new NBTTagCompound();
-            root.setTag(domain, domainNBT);
-        } else {
-            domainNBT = root.getCompoundTag(domain);
-        }
-        val subNBT = new NBTTagCompound();
-        domainNBT.setTag(manager.id(), subNBT);
-        return subNBT;
-    }
-
-    private static NBTTagCompound getManagerNBT(boolean privileged, NBTTagCompound root, ChunkDataManager manager) {
-        if (privileged) {
-            return root;
-        }
-        val domain = manager.domain();
-        if (!root.hasKey(domain)) {
-            return null;
-        }
-        val domainNBT = root.getCompoundTag(domain);
-        if (!domainNBT.hasKey(manager.id())) {
-            return null;
-        }
-        return domainNBT.getCompoundTag(manager.id());
-    }
-
-    public static void writeSectionToNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound sectionNBT) {
-        for (val manager : sectionNBTManagers.values()) {
-            manager.writeSectionToNBT(chunk, ebs,
-                                      createManagerNBT(manager.sectionPrivilegedAccess(), sectionNBT, manager));
-        }
-    }
-
-    public static void readSectionFromNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound sectionNBT) {
-        for (val manager : sectionNBTManagers.values()) {
-            manager.readSectionFromNBT(chunk, ebs,
-                                       getManagerNBT(manager.sectionPrivilegedAccess(), sectionNBT, manager));
-        }
-    }
-
-    public static void writeChunkToNBT(Chunk chunk, NBTTagCompound chunkNBT) {
-        for (val manager : chunkNBTManagers.values()) {
-            manager.writeChunkToNBT(chunk, createManagerNBT(manager.chunkPrivilegedAccess(), chunkNBT, manager));
-        }
-    }
-
-    public static void readChunkFromNBT(Chunk chunk, NBTTagCompound chunkNBT) {
-        for (val manager : chunkNBTManagers.values()) {
-            manager.readChunkFromNBT(chunk, getManagerNBT(manager.chunkPrivilegedAccess(), chunkNBT, manager));
-        }
-    }
-
-    public static Set<String> getRegisteredManagers() {
-        return Collections.unmodifiableSet(managers);
-    }
-}

src/main/java/com/falsepattern/chunk/internal/Common.java

@@ -1,13 +1,27 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal;
@@ -19,8 +33,8 @@ import org.apache.logging.log4j.Logger;
  * Non-minecraft stuff to avoid accidental classloading in spaghetti code
  */
 public class Common {
-    public static final Logger LOG = LogManager.getLogger(Tags.MODID);
+    public static final Logger LOG = LogManager.getLogger(Tags.MOD_ID);
 
-    public static final int EBS_PER_CHUNK = 16;
-    public static final int BLOCKS_PER_EBS = 16 * 16 * 16;
+    public static final int SUBCHUNKS_PER_CHUNK = 16;
+    public static final int BLOCKS_PER_SUBCHUNK = 16 * 16 * 16;
 }

src/main/java/com/falsepattern/chunk/internal/DataRegistryImpl.java

@@ -0,0 +1,479 @@
+/*
+ * ChunkAPI
+ *
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
+ */
+
+package com.falsepattern.chunk.internal;
+
+import com.falsepattern.chunk.api.DataManager;
+import lombok.Data;
+import lombok.val;
+import lombok.var;
+import org.jetbrains.annotations.Nullable;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+import net.minecraftforge.common.util.Constants;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.LoaderState;
+import cpw.mods.fml.common.StartupQuery;
+import cpw.mods.fml.common.ZipperUtil;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class DataRegistryImpl {
+    private static final Set<String> managers = new HashSet<>();
+    private static final Map<String, PacketManagerInfo> packetManagers = new HashMap<>();
+    private static final Map<String, DataManager.BlockPacketDataManager> blockPacketManagers = new HashMap<>();
+    private static final Map<String, DataManager.StorageDataManager> NBTManagers = new HashMap<>();
+    private static final Map<String, DataManager.ChunkDataManager> chunkNBTManagers = new HashMap<>();
+    private static final Map<String, DataManager.SubChunkDataManager> subChunkNBTManagers = new HashMap<>();
+    private static final Set<String> disabledManagers = new HashSet<>();
+    private static int maxPacketSize = 4;
+
+    @Data
+    private static class PacketManagerInfo {
+        public final int maxPacketSize;
+        public final DataManager.PacketDataManager manager;
+    }
+
+    public static void registerDataManager(DataManager manager)
+            throws IllegalStateException, IllegalArgumentException {
+        if (Loader.instance().getLoaderState() != LoaderState.INITIALIZATION) {
+            throw new IllegalStateException("ChunkDataManager registration is not allowed at this time! " +
+                                            "Please register your ChunkDataManager in the init phase.");
+        }
+        var id = manager.domain() + ":" + manager.id();
+        if (managers.contains(id)) {
+            throw new IllegalArgumentException("ChunkDataManager " + manager + " has a duplicate id!");
+        }
+
+        // If the manager was disabled, do not add it to the list of managers.
+        if (disabledManagers.contains(id)) {
+            return;
+        }
+
+        managers.add(id);
+        if (manager instanceof DataManager.PacketDataManager) {
+            val packetManager = (DataManager.PacketDataManager) manager;
+            val maxSize = packetManager.maxPacketSize();
+            maxPacketSize += 4 + id.getBytes(StandardCharsets.UTF_8).length + 4 + maxSize;
+            packetManagers.put(id, new PacketManagerInfo(maxSize, packetManager));
+        }
+        if (manager instanceof DataManager.BlockPacketDataManager) {
+            val blockPacketManager = (DataManager.BlockPacketDataManager) manager;
+            blockPacketManagers.put(id, blockPacketManager);
+        }
+        if (manager instanceof DataManager.StorageDataManager) {
+            NBTManagers.put(id, (DataManager.StorageDataManager) manager);
+            if (manager instanceof DataManager.ChunkDataManager) {
+                chunkNBTManagers.put(id, (DataManager.ChunkDataManager) manager);
+            }
+            if (manager instanceof DataManager.SubChunkDataManager) {
+                subChunkNBTManagers.put(id, (DataManager.SubChunkDataManager) manager);
+            }
+        }
+    }
+
+    public static void disableDataManager(String domain, String id) {
+        if (Loader.instance().getLoaderState() != LoaderState.POSTINITIALIZATION) {
+            throw new IllegalStateException("ChunkDataManager disabling is not allowed at this time! " +
+                                            "Please disable any ChunkDataManagers in the postInit phase.");
+        }
+        Common.LOG.debug("Disabling ChunkDataManager " + id + " in domain " + domain +
+                        ". See the stacktrace for the source of this event.\nThis is NOT an error.", new Throwable());
+        val manager = domain + ":" + id;
+        //Remove the manager from the list of managers, if it exists
+        if (managers.remove(manager)) {
+            //Clear the maps
+            if (packetManagers.containsKey(manager)) {
+                val removed = packetManagers.remove(manager);
+                maxPacketSize -= 4 + id.getBytes(StandardCharsets.UTF_8).length + 4 + removed.maxPacketSize;
+            }
+            blockPacketManagers.remove(manager);
+            chunkNBTManagers.remove(manager);
+            subChunkNBTManagers.remove(manager);
+            NBTManagers.remove(manager);
+        }
+
+        //Add the manager to the list of disabled managers, in case it gets registered after this disable call.
+        disabledManagers.add(manager);
+    }
+
+    public static int maxPacketSize() {
+        return maxPacketSize;
+    }
+
+    private static void writeString(ByteBuffer buffer, String string) {
+        val bytes = string.getBytes();
+        buffer.putInt(bytes.length);
+        buffer.put(bytes);
+    }
+
+    private static String readString(ByteBuffer buffer) {
+        val length = buffer.getInt();
+        val bytes = new byte[length];
+        buffer.get(bytes);
+        return new String(bytes);
+    }
+
+    public static void readFromBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, byte[] data) {
+        val buf = ByteBuffer.wrap(data);
+        buf.order(ByteOrder.LITTLE_ENDIAN);
+        int count = buf.getInt();
+        for (int i = 0; i < count; i++) {
+            val id = readString(buf);
+            val length = buf.getInt();
+            val managerInfo = packetManagers.get(id);
+            if (managerInfo == null) {
+                Common.LOG.error("Received data for unknown PacketDataManager " + id + ". Skipping.");
+                buf.position(buf.position() + length);
+                continue;
+            }
+            if (length > managerInfo.maxPacketSize) {
+                Common.LOG.error("Received packet larger than max size for PacketDataManager " + id + "! Continuing anyways, things might break!");
+            }
+            int start = buf.position();
+            val slice = createSlice(buf, start, length);
+            managerInfo.manager.readFromBuffer(chunk, subChunkMask, forceUpdate, slice);
+            buf.position(start + length);
+        }
+    }
+
+    public static int writeToBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, byte[] data) {
+        val buf = ByteBuffer.wrap(data);
+        buf.order(ByteOrder.LITTLE_ENDIAN);
+        buf.putInt(packetManagers.size());
+        for (val pair : packetManagers.entrySet()) {
+            val id = pair.getKey();
+            val managerInfo = pair.getValue();
+            writeString(buf, id);
+            int start = buf.position() + 4;
+            val slice = createSlice(buf, start, managerInfo.maxPacketSize);
+            managerInfo.manager.writeToBuffer(chunk, subChunkMask, forceUpdate, slice);
+            int length = slice.position();
+            buf.putInt(length);
+            buf.position(start + length);
+        }
+        return buf.position();
+    }
+
+    public static void writeBlockToPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet) {
+        for (val manager: blockPacketManagers.values()) {
+            manager.writeBlockToPacket(chunk, x, y, z, packet);
+        }
+    }
+
+    public static void readBlockFromPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet) {
+        for (val manager: blockPacketManagers.values()) {
+            manager.readBlockFromPacket(chunk, x, y, z, packet);
+        }
+    }
+
+    public static void writeBlockPacketToBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException {
+        buffer.writeInt(blockPacketManagers.size());
+        for (val pair: blockPacketManagers.entrySet()) {
+            val id = pair.getKey();
+            val manager = pair.getValue();
+            buffer.writeStringToBuffer(id);
+            manager.writeBlockPacketToBuffer(packet, buffer);
+        }
+    }
+
+    public static void readBlockPacketFromBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException {
+        int count = buffer.readInt();
+        for (int i = 0; i < count; i++) {
+            val id = buffer.readStringFromBuffer(1024);
+            val manager = blockPacketManagers.get(id);
+            manager.readBlockPacketFromBuffer(packet, buffer);
+        }
+    }
+
+    private static ByteBuffer createSlice(ByteBuffer buffer, int start, int length) {
+        int oldLimit = buffer.limit();
+        int oldPosition = buffer.position();
+        buffer.position(start);
+        buffer.limit(start + length);
+        ByteBuffer slice = buffer.slice();
+        buffer.limit(oldLimit);
+        buffer.position(oldPosition);
+        return slice;
+    }
+
+    private static NBTTagCompound createManagerNBT(boolean privileged, NBTTagCompound root, DataManager manager) {
+        if (privileged) {
+            return root;
+        }
+        val domain = manager.domain();
+        val id = manager.id();
+        NBTTagCompound domainNBT;
+        if (root.hasKey(domain)) {
+            domainNBT = root.getCompoundTag(domain);
+        } else {
+            domainNBT = new NBTTagCompound();
+            root.setTag(domain, domainNBT);
+        }
+        if (domainNBT.hasKey(id)) {
+            return domainNBT.getCompoundTag(id);
+        } else {
+            val subNBT = new NBTTagCompound();
+            domainNBT.setTag(id, subNBT);
+            return subNBT;
+        }
+    }
+
+    private static NBTTagCompound getManagerNBT(boolean privileged, NBTTagCompound root, DataManager manager) {
+        if (privileged) {
+            return root;
+        }
+        val domain = manager.domain();
+        if (!root.hasKey(domain)) {
+            return new NBTTagCompound();
+        }
+        val domainNBT = root.getCompoundTag(domain);
+        if (!domainNBT.hasKey(manager.id())) {
+            return new NBTTagCompound();
+        }
+        return domainNBT.getCompoundTag(manager.id());
+    }
+
+    public static void writeSubChunkToNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        for (val manager : subChunkNBTManagers.values()) {
+            manager.writeSubChunkToNBT(chunk, subChunk,
+                                       createManagerNBT(manager.subChunkPrivilegedAccess(), nbt, manager));
+        }
+    }
+
+    public static void readSubChunkFromNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        for (val manager : subChunkNBTManagers.values()) {
+            manager.readSubChunkFromNBT(chunk, subChunk,
+                                        getManagerNBT(manager.subChunkPrivilegedAccess(), nbt, manager));
+        }
+    }
+
+    public static void writeChunkToNBT(Chunk chunk, NBTTagCompound chunkNBT) {
+        for (val manager : chunkNBTManagers.values()) {
+            manager.writeChunkToNBT(chunk, createManagerNBT(manager.chunkPrivilegedAccess(), chunkNBT, manager));
+        }
+    }
+
+    public static void readChunkFromNBT(Chunk chunk, NBTTagCompound chunkNBT) {
+        for (val manager : chunkNBTManagers.values()) {
+            manager.readChunkFromNBT(chunk, getManagerNBT(manager.chunkPrivilegedAccess(), chunkNBT, manager));
+        }
+    }
+
+    public static void cloneChunk(Chunk from, Chunk to) {
+        for (val manager: chunkNBTManagers.values()) {
+            manager.cloneChunk(from, to);
+        }
+    }
+
+    public static void cloneSubChunk(Chunk fromChunk, ExtendedBlockStorage from, ExtendedBlockStorage to) {
+        for (val manager: subChunkNBTManagers.values()) {
+            manager.cloneSubChunk(fromChunk, from, to);
+        }
+    }
+
+    public static Set<String> getRegisteredManagers() {
+        return Collections.unmodifiableSet(managers);
+    }
+
+    public static void readLevelDat(NBTTagCompound tag) {
+        boolean triggerScreen = false;
+        boolean newlyInstalled = false;
+        val builder = new StringBuilder();
+        if (!tag.hasKey("version")) {
+            newlyInstalled = true;
+            builder.append("The world you are trying to load is a vanilla world, or a world that was created with a very old version of ChunkAPI.\n");
+        } // Compat code will be added here if needed.
+        val managerCompat = verifyManagerCompatibility(tag);
+        if (managerCompat != null) {
+            //Avoid duplicate messages
+            if (!newlyInstalled) {
+                builder.append("The world you are trying to load was created with a different version of ChunkAPI data managers.\n" +
+                               "Data managers are used by other mods to save extra data in chunks, and changes to these data managers can cause worlds to become corrupted.\n");
+            }
+            triggerScreen = true;
+        }
+        if (triggerScreen)
+            builder.append("ChunkAPI will attempt to load the world, but it is possible that chunks might get corrupted.\n" +
+                           "Read the following text carefully, and make sure you understand the risks before continuing.\n\n");
+        if (managerCompat != null)
+            builder.append(managerCompat);
+
+        if (triggerScreen) {
+            builder.append("\nA world backup will be automatically created in your saves directory.\n\n");
+            boolean confirmed = StartupQuery.confirm(builder.toString());
+            if (!confirmed) StartupQuery.abort();
+
+            try {
+                ZipperUtil.backupWorld();
+            } catch (IOException e) {
+                StartupQuery.notify("The world backup couldn't be created.\n\n"+e);
+                StartupQuery.abort();
+            }
+        }
+    }
+
+    private static String verifyManagerCompatibility(NBTTagCompound tag) {
+        boolean compatWarning = false;
+        StringBuilder builder = new StringBuilder();
+        val saveManagers = readManagers(tag);
+        val removedManagers = new HashSet<>(saveManagers.keySet());
+        removedManagers.removeAll(NBTManagers.keySet());
+        if (!removedManagers.isEmpty()) {
+            compatWarning = true;
+            builder.append("\nThe following data managers are no longer present:\n");
+            for (val manager : removedManagers) {
+                val saveManager = saveManagers.get(manager);
+                builder.append(manager);
+                if (saveManager.version != null)
+                    builder.append(' ').append(saveManager.version);
+                builder.append("\nUninstall information: ");
+                if (saveManager.uninstallMessage != null)
+                    builder.append(saveManager.getUninstallMessage());
+                else
+                    builder.append("No uninstall information available.");
+                builder.append('\n');
+            }
+        }
+        val addedManagers = NBTManagers.keySet()
+                                       .stream()
+                                       .filter(manager -> !manager.startsWith("minecraft:"))
+                                       .filter(manager -> !saveManagers.containsKey(manager))
+                                       .collect(Collectors.toSet());
+        if (!addedManagers.isEmpty()) {
+            compatWarning = true;
+            builder.append("\nThe following data managers have been newly added:\n");
+            for (val manager: addedManagers) {
+                val addedManager = NBTManagers.get(manager);
+                if (addedManager == null)
+                    continue;
+                builder.append(manager)
+                              .append(' ').append(addedManager.version()).append('\n');
+                val installMessage = addedManager.newInstallDescription();
+                if (installMessage != null)
+                    builder.append("Install information: ").append(addedManager.newInstallDescription()).append('\n');
+            }
+        }
+        boolean changePrompt = false;
+        for (val savedManager: saveManagers.entrySet()) {
+            val managerName = savedManager.getKey();
+            if (NBTManagers.containsKey(managerName)) {
+                val manager = savedManager.getValue();
+                val currentManager = NBTManagers.get(managerName);
+                val extraMessage = currentManager.versionChangeMessage(manager.version);
+                if (extraMessage != null) {
+                    compatWarning = true;
+                    if (!changePrompt) {
+                        builder.append("\nThe following data managers have changed versions in an incompatible way:\n");
+                        changePrompt = true;
+                    }
+                    builder.append(managerName)
+                                  .append(" has changed versions from ")
+                                  .append(manager.version)
+                                  .append(" to ")
+                                  .append(currentManager.version())
+                                  .append(".\n");
+                    builder.append("Upgrade information: ").append(extraMessage).append('\n');
+                }
+            }
+        }
+        if (!compatWarning)
+            return null;
+        return "The following managers have changed:\n" +
+               builder;
+    }
+
+    public static void writeLevelDat(NBTTagCompound tag) {
+        val managers = new NBTTagCompound();
+        tag.setTag("managers", managers);
+        tag.setString("version", Tags.MOD_VERSION);
+        for (val manager: NBTManagers.entrySet()) {
+            val name = manager.getKey();
+            if (name.startsWith("minecraft:"))
+                continue;
+            val value = manager.getValue();
+            managers.setTag(name, SaveManagerInfo.fromManager(value).toNBT());
+        }
+    }
+
+    private static Map<String, SaveManagerInfo> readManagers(NBTTagCompound tag) {
+        val managers = new HashMap<String, SaveManagerInfo>();
+        if (!tag.hasKey("managers")) return managers;
+        if (tag.func_150299_b("managers") != Constants.NBT.TAG_COMPOUND ) return managers;
+        val managerTag = tag.getCompoundTag("managers");
+        //noinspection unchecked
+        for (val key : (Set<String>)managerTag.func_150296_c()) {
+            managers.put(key, SaveManagerInfo.fromNBT(managerTag.getCompoundTag(key)));
+        }
+        return managers;
+    }
+
+    @Data
+    private static class SaveManagerInfo {
+        @Nullable
+        public final String version;
+        @Nullable
+        public final String uninstallMessage;
+
+        public NBTTagCompound toNBT() {
+            val tag = new NBTTagCompound();
+            if (version != null)
+                tag.setString("version", version);
+            if (uninstallMessage != null)
+                tag.setString("uninstallMessage", uninstallMessage);
+            return tag;
+        }
+
+        public static SaveManagerInfo fromNBT(NBTTagCompound tag) {
+            return new SaveManagerInfo(getNBTStringNullable(tag, "version"), getNBTStringNullable(tag, "uninstallMessage"));
+        }
+
+        private static String getNBTStringNullable(NBTTagCompound tag, String key) {
+            if (tag.hasKey(key) && tag.func_150299_b(key) == Constants.NBT.TAG_STRING) {
+                return tag.getString(key);
+            } else {
+                return null;
+            }
+        }
+
+        public static SaveManagerInfo fromManager(DataManager.StorageDataManager manager) {
+            return new SaveManagerInfo(manager.version(), manager.uninstallMessage());
+        }
+    }
+}

src/main/java/com/falsepattern/chunk/internal/Tags.java

@@ -1,20 +0,0 @@
-/*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
- *
- * Copyright 2023
- *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
- */
-
-package com.falsepattern.chunk.internal;
-
-public class Tags {
-    public static final String MODID = "GRADLETOKEN_MODID";
-    public static final String MODNAME = "GRADLETOKEN_MODNAME";
-    public static final String VERSION = "GRADLETOKEN_VERSION";
-    public static final String GROUPNAME = "GRADLETOKEN_GROUPNAME";
-}

src/main/java/com/falsepattern/chunk/internal/core/ChunkAPICoreModContainer.java

@@ -0,0 +1,77 @@
+/*
+ * ChunkAPI
+ *
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
+ */
+
+package com.falsepattern.chunk.internal.core;
+
+import com.falsepattern.chunk.internal.DataRegistryImpl;
+import com.falsepattern.chunk.internal.Tags;
+import com.google.common.eventbus.EventBus;
+import lombok.val;
+
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.storage.SaveHandler;
+import net.minecraft.world.storage.WorldInfo;
+import cpw.mods.fml.common.DummyModContainer;
+import cpw.mods.fml.common.LoadController;
+import cpw.mods.fml.common.ModMetadata;
+import cpw.mods.fml.common.WorldAccessContainer;
+import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
+
+import java.util.Map;
+
+public class ChunkAPICoreModContainer extends DummyModContainer implements WorldAccessContainer {
+    public ChunkAPICoreModContainer() {
+        super(createMetadata());
+    }
+
+    private static ModMetadata createMetadata() {
+        val meta = new ModMetadata();
+        meta.modId = Tags.MOD_ID + "core";
+        meta.name = Tags.MOD_NAME + " Core";
+        meta.version = Tags.MOD_VERSION;
+        meta.dependencies.add(new DefaultArtifactVersion(Tags.MOD_ID, Tags.MOD_VERSION));
+        meta.parent = Tags.MOD_ID;
+        return meta;
+    }
+
+    @Override
+    public boolean registerBus(EventBus bus, LoadController controller) {
+        return true;
+    }
+
+    @Override
+    public NBTTagCompound getDataForWriting(SaveHandler handler, WorldInfo info) {
+        val tag = new NBTTagCompound();
+        DataRegistryImpl.writeLevelDat(tag);
+        return tag;
+    }
+
+    @Override
+    public void readData(SaveHandler handler, WorldInfo info, Map<String, NBTBase> propertyMap, NBTTagCompound tag) {
+        DataRegistryImpl.readLevelDat(tag);
+    }
+}

src/main/java/com/falsepattern/chunk/internal/core/CoreLoadingPlugin.java

@@ -0,0 +1,61 @@
+/*
+ * ChunkAPI
+ *
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
+ */
+
+package com.falsepattern.chunk.internal.core;
+
+import com.falsepattern.chunk.internal.Tags;
+
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
+
+import java.util.Map;
+
+@IFMLLoadingPlugin.TransformerExclusions(Tags.ROOT_PKG + ".internal.core")
+public class CoreLoadingPlugin implements IFMLLoadingPlugin {
+    @Override
+    public String[] getASMTransformerClass() {
+        return new String[0];
+    }
+
+    @Override
+    public String getModContainerClass() {
+        return Tags.ROOT_PKG + ".internal.core.ChunkAPICoreModContainer";
+    }
+
+    @Override
+    public String getSetupClass() {
+        return null;
+    }
+
+    @Override
+    public void injectData(Map<String, Object> data) {
+
+    }
+
+    @Override
+    public String getAccessTransformerClass() {
+        return null;
+    }
+}

src/main/java/com/falsepattern/chunk/internal/impl/CustomPacketBlockChange.java

@@ -0,0 +1,13 @@
+package com.falsepattern.chunk.internal.impl;
+
+import net.minecraft.world.chunk.Chunk;
+
+public interface CustomPacketBlockChange {
+    void chunkapi$init(int x, int y, int z, Chunk chunk);
+    void chunkapi$x(int value);
+    void chunkapi$y(int value);
+    void chunkapi$z(int value);
+    int chunkapi$x();
+    int chunkapi$y();
+    int chunkapi$z();
+}

src/main/java/com/falsepattern/chunk/internal/impl/CustomPacketMultiBlockChange.java

@@ -0,0 +1,9 @@
+package com.falsepattern.chunk.internal.impl;
+
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.world.chunk.Chunk;
+
+public interface CustomPacketMultiBlockChange {
+    void chunkapi$init(int count, short[] crammedPositions, Chunk chunk);
+    S23PacketBlockChange[] chunkapi$subPackets();
+}

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/client/vanilla/ChunkMixin.java

@@ -1,18 +1,32 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.mixin.mixins.client.vanilla;
 
-import com.falsepattern.chunk.internal.ChunkDataRegistryImpl;
+import com.falsepattern.chunk.internal.DataRegistryImpl;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Overwrite;
 import org.spongepowered.asm.mixin.Shadow;
@@ -22,7 +36,6 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
-
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 
@@ -58,7 +71,7 @@ public abstract class ChunkMixin {
      */
     @SideOnly(Side.CLIENT)
     @Overwrite
-    public void fillChunk(byte[] data, int ebsMask, int ebsMSBMask, boolean forceUpdate) {
+    public void fillChunk(byte[] data, int subChunkMask, int subChunkMSBMask, boolean forceUpdate) {
         for (Object o : chunkTileEntityMap.values()) {
             TileEntity tileEntity = (TileEntity) o;
             tileEntity.updateContainingBlockInfo();
@@ -69,7 +82,7 @@ public abstract class ChunkMixin {
         boolean hasSky = !this.worldObj.provider.hasNoSky;
 
         for (int i = 0; i < storageArrays.length; i++) {
-            if ((ebsMask & (1 << i)) != 0) {
+            if ((subChunkMask & (1 << i)) != 0) {
                 if (storageArrays[i] == null) {
                     storageArrays[i] = new ExtendedBlockStorage(i << 4, hasSky);
                 }
@@ -78,10 +91,10 @@ public abstract class ChunkMixin {
             }
         }
 
-        ChunkDataRegistryImpl.readFromBuffer((Chunk) (Object) this, ebsMask, forceUpdate, data);
+        DataRegistryImpl.readFromBuffer((Chunk) (Object) this, subChunkMask, forceUpdate, data);
 
         for (int i = 0; i < storageArrays.length; ++i) {
-            if ((storageArrays[i] != null) && ((ebsMask & (1 << i)) != 0)) {
+            if ((storageArrays[i] != null) && ((subChunkMask & (1 << i)) != 0)) {
                 storageArrays[i].removeInvalidBlocks();
             }
         }

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/client/vanilla/NetHandlerPlayClientMixin.java

@@ -0,0 +1,57 @@
+package com.falsepattern.chunk.internal.mixin.mixins.client.vanilla;
+
+import com.falsepattern.chunk.internal.DataRegistryImpl;
+import com.falsepattern.chunk.internal.impl.CustomPacketBlockChange;
+import com.falsepattern.chunk.internal.impl.CustomPacketMultiBlockChange;
+import lombok.val;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.network.play.INetHandlerPlayClient;
+import net.minecraft.network.play.server.S22PacketMultiBlockChange;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+
+@Mixin(NetHandlerPlayClient.class)
+public abstract class NetHandlerPlayClientMixin implements INetHandlerPlayClient {
+    @Shadow
+    private WorldClient clientWorldController;
+
+    @Inject(method = "handleBlockChange",
+            at = @At(value = "RETURN"),
+            require = 1)
+    private void doHandleBlockChange(S23PacketBlockChange packetIn, CallbackInfo ci) {
+        val cPacket = (CustomPacketBlockChange) packetIn;
+        val x = cPacket.chunkapi$x();
+        val y = cPacket.chunkapi$y();
+        val z = cPacket.chunkapi$z();
+        val chunk = clientWorldController.getChunkFromBlockCoords(x, z);
+        DataRegistryImpl.readBlockFromPacket(chunk, x & 0xf, y, z & 0xf, packetIn);
+    }
+
+    /**
+     * @author FalsePattern
+     * @reason Integrate
+     */
+    @Overwrite
+    public void handleMultiBlockChange(S22PacketMultiBlockChange packetIn) {
+        val cX = packetIn.func_148920_c().chunkXPos;
+        val cZ = packetIn.func_148920_c().chunkZPos;
+        val chunk = clientWorldController.getChunkFromChunkCoords(cX, cZ);
+        val bX = cX * 16;
+        val bZ = cZ * 16;
+        for (val subPacket : ((CustomPacketMultiBlockChange) packetIn).chunkapi$subPackets()) {
+            val cSub = (CustomPacketBlockChange) subPacket;
+            val x = cSub.chunkapi$x();
+            val y = cSub.chunkapi$y();
+            val z = cSub.chunkapi$z();
+            this.clientWorldController.func_147492_c(x + bX, y, z + bZ, subPacket.func_148880_c(), subPacket.func_148881_g());
+            DataRegistryImpl.readBlockFromPacket(chunk, x, y, z, subPacket);
+        }
+    }
+}

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/common/vanilla/AnvilChunkLoaderMixin.java

@@ -1,18 +1,32 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.mixin.mixins.common.vanilla;
 
-import com.falsepattern.chunk.internal.ChunkDataRegistryImpl;
+import com.falsepattern.chunk.internal.DataRegistryImpl;
 import lombok.val;
 import org.apache.logging.log4j.Level;
 import org.spongepowered.asm.mixin.Mixin;
@@ -47,11 +61,9 @@ public abstract class AnvilChunkLoaderMixin {
         nbt.setInteger("xPos", chunk.xPosition);
         nbt.setInteger("zPos", chunk.zPosition);
         nbt.setLong("LastUpdate", world.getTotalWorldTime());
-        nbt.setIntArray("HeightMap", chunk.heightMap);
         nbt.setBoolean("TerrainPopulated", chunk.isTerrainPopulated);
-        nbt.setBoolean("LightPopulated", chunk.isLightPopulated);
         nbt.setLong("InhabitedTime", chunk.inhabitedTime);
-        writeSections(chunk, nbt);
+        writeSubChunks(chunk, nbt);
         writeCustomData(chunk, nbt);
         writeEntities(chunk, world, nbt);
     }
@@ -68,11 +80,9 @@ public abstract class AnvilChunkLoaderMixin {
         int x = nbt.getInteger("xPos");
         int z = nbt.getInteger("zPos");
         Chunk chunk = new Chunk(world, x, z);
-        chunk.heightMap = nbt.getIntArray("HeightMap");
         chunk.isTerrainPopulated = nbt.getBoolean("TerrainPopulated");
-        chunk.isLightPopulated = nbt.getBoolean("LightPopulated");
         chunk.inhabitedTime = nbt.getLong("InhabitedTime");
-        readSections(chunk, nbt);
+        readSubChunks(chunk, nbt);
         readCustomData(chunk, nbt);
 
         // End this method here and split off entity loading to another method
@@ -80,46 +90,46 @@ public abstract class AnvilChunkLoaderMixin {
     }
 
     private void readCustomData(Chunk chunk, NBTTagCompound nbt) {
-        ChunkDataRegistryImpl.readChunkFromNBT(chunk, nbt);
+        DataRegistryImpl.readChunkFromNBT(chunk, nbt);
     }
 
-    private void readSections(Chunk chunk, NBTTagCompound nbt) {
-        NBTTagList sections = nbt.getTagList("Sections", 10);
+    private void readSubChunks(Chunk chunk, NBTTagCompound nbt) {
+        NBTTagList subChunksNBT = nbt.getTagList("Sections", 10);
         byte segments = 16;
-        ExtendedBlockStorage[] ebsList = new ExtendedBlockStorage[segments];
+        ExtendedBlockStorage[] subChunkList = new ExtendedBlockStorage[segments];
 
-        for (int k = 0; k < sections.tagCount(); ++k) {
-            NBTTagCompound section = sections.getCompoundTagAt(k);
-            byte yLevel = section.getByte("Y");
-            ExtendedBlockStorage ebs = new ExtendedBlockStorage(yLevel << 4, !chunk.worldObj.provider.hasNoSky);
-            ChunkDataRegistryImpl.readSectionFromNBT(chunk, ebs, section);
+        for (int k = 0; k < subChunksNBT.tagCount(); ++k) {
+            NBTTagCompound subChunkNBT = subChunksNBT.getCompoundTagAt(k);
+            byte yLevel = subChunkNBT.getByte("Y");
+            ExtendedBlockStorage subChunk = new ExtendedBlockStorage(yLevel << 4, !chunk.worldObj.provider.hasNoSky);
+            DataRegistryImpl.readSubChunkFromNBT(chunk, subChunk, subChunkNBT);
 
-            ebs.removeInvalidBlocks();
-            ebsList[yLevel] = ebs;
+            subChunk.removeInvalidBlocks();
+            subChunkList[yLevel] = subChunk;
         }
 
-        chunk.setStorageArrays(ebsList);
+        chunk.setStorageArrays(subChunkList);
     }
 
     private void writeCustomData(Chunk chunk, NBTTagCompound nbt) {
-        ChunkDataRegistryImpl.writeChunkToNBT(chunk, nbt);
+        DataRegistryImpl.writeChunkToNBT(chunk, nbt);
     }
 
-    private void writeSections(Chunk chunk, NBTTagCompound nbt) {
-        ExtendedBlockStorage[] ebsList = chunk.getBlockStorageArray();
-        NBTTagList sections = new NBTTagList();
-        NBTTagCompound section;
+    private void writeSubChunks(Chunk chunk, NBTTagCompound nbt) {
+        ExtendedBlockStorage[] subChunks = chunk.getBlockStorageArray();
+        NBTTagList subChunksNBT = new NBTTagList();
+        NBTTagCompound subChunkNBT;
 
-        for (ExtendedBlockStorage ebs : ebsList) {
-            if (ebs != null) {
-                section = new NBTTagCompound();
-                section.setByte("Y", (byte) (ebs.getYLocation() >> 4 & 255));
-                ChunkDataRegistryImpl.writeSectionToNBT(chunk, ebs, section);
-                sections.appendTag(section);
+        for (ExtendedBlockStorage subChunk : subChunks) {
+            if (subChunk != null) {
+                subChunkNBT = new NBTTagCompound();
+                subChunkNBT.setByte("Y", (byte) (subChunk.getYLocation() >> 4 & 255));
+                DataRegistryImpl.writeSubChunkToNBT(chunk, subChunk, subChunkNBT);
+                subChunksNBT.appendTag(subChunkNBT);
             }
         }
 
-        nbt.setTag("Sections", sections);
+        nbt.setTag("Sections", subChunksNBT);
     }
 
     private void writeEntities(Chunk chunk, World world, NBTTagCompound nbt) {

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/common/vanilla/PlayerInstanceMixin.java

@@ -0,0 +1,28 @@
+package com.falsepattern.chunk.internal.mixin.mixins.common.vanilla;
+
+import com.falsepattern.chunk.internal.impl.CustomPacketMultiBlockChange;
+import lombok.val;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.S22PacketMultiBlockChange;
+import net.minecraft.server.management.PlayerManager;
+import net.minecraft.world.chunk.Chunk;
+
+@Mixin(PlayerManager.PlayerInstance.class)
+public abstract class PlayerInstanceMixin {
+    /**
+     * S22PacketMultiBlockChange is an absolute, utter pain in the ass to properly integrate with.
+     */
+    @Redirect(method = "sendChunkUpdate",
+              at = @At(value = "NEW",
+                       target = "(I[SLnet/minecraft/world/chunk/Chunk;)Lnet/minecraft/network/play/server/S22PacketMultiBlockChange;"),
+              require = 1)
+    private S22PacketMultiBlockChange hijackPacket(int count, short[] positions, Chunk chunk) {
+        val packet = new S22PacketMultiBlockChange();
+        ((CustomPacketMultiBlockChange)packet).chunkapi$init(count, positions, chunk);
+        return packet;
+    }
+}

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/common/vanilla/S21PacketChunkDataMixin.java

@@ -1,24 +1,36 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.mixin.mixins.common.vanilla;
 
-import com.falsepattern.chunk.internal.ChunkDataRegistryImpl;
+import com.falsepattern.chunk.internal.DataRegistryImpl;
 import lombok.val;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Overwrite;
 import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.Constant;
-import org.spongepowered.asm.mixin.injection.ModifyConstant;
 
 import net.minecraft.network.PacketBuffer;
 import net.minecraft.network.play.server.S21PacketChunkData;
@@ -42,7 +54,7 @@ public abstract class S21PacketChunkDataMixin {
     @Shadow(aliases = "field_149282_b")
     private int zPosition;
     @Shadow(aliases = "field_149283_c")
-    private int ebsMask;
+    private int subChunkMask;
     @Shadow(aliases = "field_149281_e")
     private byte[] deflatedData;
     @Shadow(aliases = "field_149278_f")
@@ -52,11 +64,14 @@ public abstract class S21PacketChunkDataMixin {
     @Shadow(aliases = "field_149285_h")
     private int deflatedSize;
 
-    @ModifyConstant(method = {"<clinit>", "func_149275_c"},
-                    constant = @Constant(intValue = 196864),
-                    require = 1)
-    private static int increasePacketSize(int constant) {
-        return ChunkDataRegistryImpl.maxPacketSize();
+
+    /**
+     * @author FalsePattern
+     * @reason Extend capacity
+     */
+    @Overwrite
+    public static int func_149275_c() {
+        return DataRegistryImpl.maxPacketSize();
     }
 
     /**
@@ -64,25 +79,25 @@ public abstract class S21PacketChunkDataMixin {
      * @reason Replace functionality
      */
     @Overwrite
-    public static S21PacketChunkData.Extracted func_149269_a(Chunk chunk, boolean forceUpdate, int ebsMask) {
-        ExtendedBlockStorage[] ebs = chunk.getBlockStorageArray();
+    public static S21PacketChunkData.Extracted func_149269_a(Chunk chunk, boolean forceUpdate, int subChunkMask) {
+        ExtendedBlockStorage[] subChunks = chunk.getBlockStorageArray();
         S21PacketChunkData.Extracted extracted = new S21PacketChunkData.Extracted();
 
-        if (buffer.length < ChunkDataRegistryImpl.maxPacketSize()) {
-            buffer = new byte[ChunkDataRegistryImpl.maxPacketSize()];
+        if (buffer.length < DataRegistryImpl.maxPacketSize()) {
+            buffer = new byte[DataRegistryImpl.maxPacketSize()];
         }
 
         if (forceUpdate) {
             chunk.sendUpdates = true;
         }
 
-        for (int i = 0; i < ebs.length; ++i) {
-            if (ebs[i] != null && (!forceUpdate || !ebs[i].isEmpty()) && (ebsMask & 1 << i) != 0) {
+        for (int i = 0; i < subChunks.length; ++i) {
+            if (subChunks[i] != null && (!forceUpdate || !subChunks[i].isEmpty()) && (subChunkMask & 1 << i) != 0) {
                 extracted.field_150280_b |= 1 << i;
             }
         }
 
-        int length = ChunkDataRegistryImpl.writeToBuffer(chunk, extracted.field_150280_b, forceUpdate, buffer);
+        int length = DataRegistryImpl.writeToBuffer(chunk, extracted.field_150280_b, forceUpdate, buffer);
 
         extracted.field_150282_a = new byte[length];
         System.arraycopy(buffer, 0, extracted.field_150282_a, 0, length);
@@ -110,9 +125,8 @@ public abstract class S21PacketChunkDataMixin {
         }
         data.writeInt(xPosition);
         data.writeInt(zPosition);
-        System.out.println("Writing chunk packet (" + xPosition + ", " + zPosition + ")");
         data.writeBoolean(forceUpdate);
-        data.writeShort((short) (ebsMask & 0xFFFF));
+        data.writeShort((short) (subChunkMask & 0xFFFF));
         data.writeInt(this.data.length);
         data.writeInt(deflatedSize);
         data.writeBytes(deflatedData, 0, deflatedSize);
@@ -126,9 +140,8 @@ public abstract class S21PacketChunkDataMixin {
     public void readPacketData(PacketBuffer data) throws IOException {
         xPosition = data.readInt();
         zPosition = data.readInt();
-        System.out.println("Reading chunk packet (" + xPosition + ", " + zPosition + ")");
         forceUpdate = data.readBoolean();
-        ebsMask = data.readShort() & 0xFFFF;
+        subChunkMask = data.readShort() & 0xFFFF;
         this.data = new byte[data.readInt()];
         deflatedSize = data.readInt();
         if (buffer.length < deflatedSize) {

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/common/vanilla/S22PacketMultiBlockChangeMixin.java

@@ -0,0 +1,115 @@
+package com.falsepattern.chunk.internal.mixin.mixins.common.vanilla;
+
+import com.falsepattern.chunk.internal.DataRegistryImpl;
+import com.falsepattern.chunk.internal.impl.CustomPacketBlockChange;
+import com.falsepattern.chunk.internal.impl.CustomPacketMultiBlockChange;
+import io.netty.buffer.AbstractByteBuf;
+import io.netty.buffer.Unpooled;
+import lombok.val;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.INetHandlerPlayClient;
+import net.minecraft.network.play.server.S22PacketMultiBlockChange;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.world.ChunkCoordIntPair;
+import net.minecraft.world.chunk.Chunk;
+import cpw.mods.fml.common.network.ByteBufUtils;
+
+import java.io.IOException;
+
+@Mixin(S22PacketMultiBlockChange.class)
+public abstract class S22PacketMultiBlockChangeMixin implements CustomPacketMultiBlockChange {
+    @Shadow(aliases = "field_148925_b")
+    private ChunkCoordIntPair coord;
+
+    private S23PacketBlockChange[] subPackets;
+
+    @SuppressWarnings("DefaultAnnotationParam")
+    @Inject(method = "<init>(I[SLnet/minecraft/world/chunk/Chunk;)V",
+            at = @At(value = "FIELD",
+                     target = "Lnet/minecraft/network/play/server/S22PacketMultiBlockChange;field_148925_b:Lnet/minecraft/world/ChunkCoordIntPair;",
+                     unsafe = true),
+            require = 1)
+    private void suppressConstructor(int p_i45181_1_, short[] crammedPositions, Chunk chunk, CallbackInfo ci) {
+        throw new IllegalStateException(
+                "S22PacketMultiBlockChange constructor is not supported by ChunkAPI. Please report this to FalsePattern!");
+    }
+
+    @Override
+    public void chunkapi$init(int count, short[] crammedPositions, Chunk chunk) {
+        coord = new ChunkCoordIntPair(chunk.xPosition, chunk.zPosition);
+        subPackets = new S23PacketBlockChange[count];
+        for (int i = 0; i < count; ++i) {
+            val subPacket = new S23PacketBlockChange();
+            int x = crammedPositions[i] >> 12 & 0xf;
+            int z = crammedPositions[i] >> 8 & 0xf;
+            int y = crammedPositions[i] & 0xff;
+            ((CustomPacketBlockChange) subPacket).chunkapi$init(x, y, z, chunk);
+            subPackets[i] = subPacket;
+        }
+    }
+
+
+    /**
+     * Reads the raw packet data from the data stream.
+     *
+     * @author FalsePattern
+     * @reason Integrate
+     */
+    @Overwrite
+    public void readPacketData(PacketBuffer data) throws IOException {
+        coord = new ChunkCoordIntPair(data.readInt(), data.readInt());
+        int count = data.readVarIntFromBuffer();
+        subPackets = new S23PacketBlockChange[count];
+        for (int i = 0; i < count; ++i) {
+            val subPacket = new S23PacketBlockChange();
+            subPackets[i] = subPacket;
+            val cSub = (CustomPacketBlockChange) subPacket;
+            val pos = data.readUnsignedShort();
+            val x = pos >> 12 & 0xf;
+            val z = pos >> 8 & 0xf;
+            val y = pos & 0xff;
+            cSub.chunkapi$x(x);
+            cSub.chunkapi$y(y);
+            cSub.chunkapi$z(z);
+            DataRegistryImpl.readBlockPacketFromBuffer(subPacket, data);
+        }
+    }
+
+    /**
+     * Writes the raw packet data to the data stream.
+     *
+     * @author FalsePattern
+     * @reason Integrate
+     */
+    @Overwrite
+    public void writePacketData(PacketBuffer data) throws IOException {
+        data.writeInt(coord.chunkXPos);
+        data.writeInt(coord.chunkZPos);
+
+        if (subPackets != null) {
+            data.writeVarIntToBuffer(subPackets.length);
+            for (val subPacket : subPackets) {
+                val cSub = (CustomPacketBlockChange) subPacket;
+                int pos = ((cSub.chunkapi$x() & 0xf) << 12) |
+                          ((cSub.chunkapi$z() & 0xf) << 8) |
+                          (cSub.chunkapi$y() & 0xff);
+                data.writeShort(pos);
+                DataRegistryImpl.writeBlockPacketToBuffer(subPacket, data);
+            }
+        } else {
+            data.writeInt(0);
+        }
+    }
+
+    @Override
+    public S23PacketBlockChange[] chunkapi$subPackets() {
+        return subPackets;
+    }
+}

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/common/vanilla/S23PacketBlockChangeMixin.java

@@ -0,0 +1,107 @@
+package com.falsepattern.chunk.internal.mixin.mixins.common.vanilla;
+
+import com.falsepattern.chunk.internal.BlockPosUtil;
+import com.falsepattern.chunk.internal.DataRegistryImpl;
+import com.falsepattern.chunk.internal.impl.CustomPacketBlockChange;
+import lombok.SneakyThrows;
+import lombok.val;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import net.minecraft.block.Block;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.S23PacketBlockChange;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+
+import java.io.IOException;
+
+@Mixin(S23PacketBlockChange.class)
+public abstract class S23PacketBlockChangeMixin implements CustomPacketBlockChange {
+    @Shadow(aliases = "field_148887_a")
+    private int xCoord;
+    @Shadow(aliases = "field_148885_b")
+    private int yCoord;
+    @Shadow(aliases = "field_148886_c")
+    private int zCoord;
+
+    @Shadow public Block field_148883_d;
+
+    @Shadow public int field_148884_e;
+
+    @Override
+    public void chunkapi$init(int x, int y, int z, Chunk chunk) {
+        xCoord = x;
+        yCoord = y;
+        zCoord = z;
+        field_148883_d = chunk.getBlock(x, y, z);
+        field_148884_e = chunk.getBlockMetadata(x, y, z);
+        DataRegistryImpl.writeBlockToPacket(chunk, x, y, z, (S23PacketBlockChange) (Object) this);
+    }
+
+    @Inject(method = "<init>(IIILnet/minecraft/world/World;)V",
+            at = @At("RETURN"),
+            require = 1)
+    private void writeBlockToPacket(int x, int y, int z, World world, CallbackInfo ci) {
+        val chunk = world.getChunkFromBlockCoords(x, z);
+        DataRegistryImpl.writeBlockToPacket(chunk, x & 0xf, y, z & 0xf, (S23PacketBlockChange) (Object) this);
+    }
+
+    /**
+     * @author FalsePattern
+     * @reason Integrate
+     */
+    @Overwrite
+    public void readPacketData(PacketBuffer data) throws IOException {
+        long packed = data.readLong();
+        xCoord = BlockPosUtil.getX(packed);
+        yCoord = BlockPosUtil.getY(packed);
+        zCoord = BlockPosUtil.getZ(packed);
+        DataRegistryImpl.readBlockPacketFromBuffer((S23PacketBlockChange) (Object) this, data);
+    }
+
+    /**
+     * @author FalsePattern
+     * @reason Integrate
+     */
+    @Overwrite
+    public void writePacketData(PacketBuffer data) throws IOException {
+        long packed = BlockPosUtil.packToLong(xCoord, yCoord, zCoord);
+        data.writeLong(packed);
+        DataRegistryImpl.writeBlockPacketToBuffer((S23PacketBlockChange) (Object) this, data);
+    }
+
+    @Override
+    public void chunkapi$x(int value) {
+        xCoord = value;
+    }
+
+    @Override
+    public void chunkapi$y(int value) {
+        yCoord = value;
+    }
+
+    @Override
+    public void chunkapi$z(int value) {
+        zCoord = value;
+    }
+
+    @Override
+    public int chunkapi$x() {
+        return xCoord;
+    }
+
+    @Override
+    public int chunkapi$y() {
+        return yCoord;
+    }
+
+    @Override
+    public int chunkapi$z() {
+        return zCoord;
+    }
+}

src/main/java/com/falsepattern/chunk/internal/mixin/mixins/common/vanilla/S26PacketMapChunkBulkMixin.java

@@ -1,13 +1,27 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.mixin.mixins.common.vanilla;
@@ -39,7 +53,9 @@ public abstract class S26PacketMapChunkBulkMixin {
     @Shadow(aliases = "field_149264_b")
     private int[] zPositions;
     @Shadow(aliases = "field_149265_c")
-    private int[] ebsMasks;
+    private int[] subChunkMasks;
+    @Shadow(aliases = "field_149262_d")
+    private int[] subChunkMSBMasks;
     @Shadow(aliases = "field_149261_g")
     private int deflatedSize;
     @Shadow(aliases = "field_149267_h")
@@ -65,7 +81,8 @@ public abstract class S26PacketMapChunkBulkMixin {
         skylight = data.readBoolean();
         xPositions = new int[chunkCount];
         zPositions = new int[chunkCount];
-        ebsMasks = new int[chunkCount];
+        subChunkMasks = new int[chunkCount];
+        subChunkMSBMasks = new int[chunkCount];
         datas = new byte[chunkCount][];
 
         if (inflaterBuffer.length < deflatedSize) {
@@ -91,7 +108,7 @@ public abstract class S26PacketMapChunkBulkMixin {
             val size = sizes[i];
             xPositions[i] = data.readInt();
             zPositions[i] = data.readInt();
-            ebsMasks[i] = data.readUnsignedShort();
+            subChunkMasks[i] = data.readUnsignedShort();
 
             datas[i] = new byte[size];
             System.arraycopy(buf, pos, datas[i], 0, size);
@@ -124,7 +141,7 @@ public abstract class S26PacketMapChunkBulkMixin {
         for (int i = 0; i < xPositions.length; ++i) {
             data.writeInt(xPositions[i]);
             data.writeInt(zPositions[i]);
-            data.writeShort((short) (ebsMasks[i] & 65535));
+            data.writeShort((short) (subChunkMasks[i] & 65535));
         }
     }
 }

src/main/java/com/falsepattern/chunk/internal/mixin/plugin/Mixin.java

@@ -1,13 +1,27 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.mixin.plugin;
@@ -26,10 +40,14 @@ import static com.falsepattern.lib.mixin.IMixin.PredicateHelpers.always;
 public enum Mixin implements IMixin {
     // @formatter:off
     AnvilChunkLoaderMixin(Side.COMMON, always(), "vanilla.AnvilChunkLoaderMixin"),
+    PlayerInstanceMixin(Side.COMMON, always(), "vanilla.PlayerInstanceMixin"),
     S21PacketChunkDataMixin(Side.COMMON, always(), "vanilla.S21PacketChunkDataMixin"),
+    S22PacketMultiBlockChangeMixin(Side.COMMON, always(), "vanilla.S22PacketMultiBlockChangeMixin"),
+    S23PacketBlockChangeMixin(Side.COMMON, always(), "vanilla.S23PacketBlockChangeMixin"),
     S26PacketMapChunkBulkMixin(Side.COMMON, always(), "vanilla.S26PacketMapChunkBulkMixin"),
 
     ChunkMixin(Side.CLIENT, always(), "vanilla.ChunkMixin"),
+    NetHandlerPlayClientMixin(Side.CLIENT, always(), "vanilla.NetHandlerPlayClientMixin"),
     ;
     // @formatter:on
 

src/main/java/com/falsepattern/chunk/internal/mixin/plugin/MixinPlugin.java

@@ -1,13 +1,27 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.mixin.plugin;
@@ -21,7 +35,7 @@ import org.apache.logging.log4j.Logger;
 
 public class MixinPlugin implements IMixinPlugin {
     @Getter
-    private final Logger logger = IMixinPlugin.createLogger(Tags.MODNAME);
+    private final Logger logger = IMixinPlugin.createLogger(Tags.MOD_NAME);
 
     @Override
     public ITargetedMod[] getTargetedModEnumValues() {

src/main/java/com/falsepattern/chunk/internal/mixin/plugin/TargetedMod.java

@@ -1,13 +1,27 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.mixin.plugin;

src/main/java/com/falsepattern/chunk/internal/package-info.java

@@ -1,13 +1,27 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 /**

src/main/java/com/falsepattern/chunk/internal/vanilla/BiomeManager.java

@@ -1,18 +1,33 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.vanilla;
 
-import com.falsepattern.chunk.api.ChunkDataManager;
+import com.falsepattern.chunk.api.ArrayUtil;
+import com.falsepattern.chunk.api.DataManager;
 import org.jetbrains.annotations.NotNull;
 
 import net.minecraft.nbt.NBTTagCompound;
@@ -21,7 +36,7 @@ import net.minecraft.world.chunk.Chunk;
 import java.nio.ByteBuffer;
 
 public class BiomeManager extends VanillaManager
-        implements ChunkDataManager.PacketDataManager, ChunkDataManager.ChunkNBTDataManager {
+        implements DataManager.PacketDataManager, DataManager.ChunkDataManager {
     public static final int BYTES_PER_CHUNK = 256;
 
     @Override
@@ -35,14 +50,14 @@ public class BiomeManager extends VanillaManager
     }
 
     @Override
-    public void writeToBuffer(@NotNull Chunk chunk, int ebsMask, boolean forceUpdate, @NotNull ByteBuffer data) {
+    public void writeToBuffer(@NotNull Chunk chunk, int subChunkMask, boolean forceUpdate, @NotNull ByteBuffer buffer) {
         if (forceUpdate) {
-            data.put(chunk.getBiomeArray());
+            buffer.put(chunk.getBiomeArray());
         }
     }
 
     @Override
-    public void readFromBuffer(@NotNull Chunk chunk, int ebsMask, boolean forceUpdate, @NotNull ByteBuffer buffer) {
+    public void readFromBuffer(@NotNull Chunk chunk, int subChunkMask, boolean forceUpdate, @NotNull ByteBuffer buffer) {
         if (forceUpdate) {
             buffer.get(chunk.getBiomeArray());
         }
@@ -65,4 +80,9 @@ public class BiomeManager extends VanillaManager
             chunk.setBiomeArray(nbt.getByteArray("Biomes"));
         }
     }
+
+    @Override
+    public void cloneChunk(Chunk from, Chunk to) {
+        to.setBiomeArray(ArrayUtil.copyArray(from.getBiomeArray(), to.getBiomeArray()));
+    }
 }

src/main/java/com/falsepattern/chunk/internal/vanilla/BlockIDManager.java

@@ -1,34 +1,56 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.vanilla;
 
-import com.falsepattern.chunk.api.ChunkDataManager;
+import com.falsepattern.chunk.api.ArrayUtil;
+import com.falsepattern.chunk.api.DataManager;
 import lombok.val;
 
+import net.minecraft.block.Block;
 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.S23PacketBlockChange;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.NibbleArray;
 import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
+import java.io.IOException;
 import java.nio.ByteBuffer;
 
-import static com.falsepattern.chunk.internal.Common.BLOCKS_PER_EBS;
-import static com.falsepattern.chunk.internal.Common.EBS_PER_CHUNK;
+import static com.falsepattern.chunk.internal.Common.BLOCKS_PER_SUBCHUNK;
+import static com.falsepattern.chunk.internal.Common.SUBCHUNKS_PER_CHUNK;
 
 public class BlockIDManager extends VanillaManager
-        implements ChunkDataManager.PacketDataManager, ChunkDataManager.SectionNBTDataManager {
-    private static final int LSB_BYTES_PER_EBS = BLOCKS_PER_EBS;
-    private static final int MSB_BYTES_PER_EBS = BLOCKS_PER_EBS / 2;
+        implements
+        DataManager.PacketDataManager,
+        DataManager.BlockPacketDataManager,
+        DataManager.SubChunkDataManager {
+    private static final int LSB_BYTES_PER_SUBCHUNK = BLOCKS_PER_SUBCHUNK;
+    private static final int MSB_BYTES_PER_SUBCHUNK = BLOCKS_PER_SUBCHUNK / 2;
     private static final int HEADER_SIZE = 2;
 
     @Override
@@ -38,74 +60,99 @@ public class BlockIDManager extends VanillaManager
 
     @Override
     public int maxPacketSize() {
-        return HEADER_SIZE + EBS_PER_CHUNK * (LSB_BYTES_PER_EBS + MSB_BYTES_PER_EBS);
+        return HEADER_SIZE + SUBCHUNKS_PER_CHUNK * (LSB_BYTES_PER_SUBCHUNK + MSB_BYTES_PER_SUBCHUNK);
     }
 
     @Override
-    public void writeToBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer data) {
-        val ebsArray = chunk.getBlockStorageArray();
-        int currentPos = data.position();
-        data.putShort((short) 0);
+    public void writeToBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer) {
+        val subChunks = chunk.getBlockStorageArray();
+        int currentPos = buffer.position();
+        buffer.putShort((short) 0);
         int msbMask = 0;
-        for (int i = 0; i < ebsArray.length; i++) {
-            if ((ebsMask & (1 << i)) != 0) {
-                val ebs = ebsArray[i];
-                val lsb = ebs.getBlockLSBArray();
-                val msb = ebs.getBlockMSBArray();
-                data.put(lsb);
+        for (int i = 0; i < subChunks.length; i++) {
+            if ((subChunkMask & (1 << i)) != 0) {
+                val subChunk = subChunks[i];
+                val lsb = subChunk.getBlockLSBArray();
+                val msb = subChunk.getBlockMSBArray();
+                buffer.put(lsb);
                 if (msb != null) {
                     msbMask |= 1 << i;
-                    data.put(msb.data);
+                    buffer.put(msb.data);
                 }
             }
         }
-        int endPos = data.position();
-        data.position(currentPos);
-        data.putShort((short) msbMask);
-        data.position(endPos);
+        int endPos = buffer.position();
+        buffer.position(currentPos);
+        buffer.putShort((short) msbMask);
+        buffer.position(endPos);
     }
 
     @Override
-    public void readFromBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer buffer) {
-        val ebsArray = chunk.getBlockStorageArray();
+    public void readFromBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer) {
+        val subChunks = chunk.getBlockStorageArray();
         val msbMask = buffer.getShort() & 0xFFFF;
-        for (int i = 0; i < ebsArray.length; i++) {
-            val ebs = ebsArray[i];
-            if ((ebsMask & (1 << i)) != 0 && ebs != null) {
-                buffer.get(ebs.getBlockLSBArray());
+        for (int i = 0; i < subChunks.length; i++) {
+            val subChunk = subChunks[i];
+            if ((subChunkMask & (1 << i)) != 0 && subChunk != null) {
+                buffer.get(subChunk.getBlockLSBArray());
                 if ((msbMask & (1 << i)) != 0) {
-                    val msb = ebs.getBlockMSBArray();
+                    val msb = subChunk.getBlockMSBArray();
                     if (msb == null) {
-                        ebs.createBlockMSBArray();
+                        subChunk.createBlockMSBArray();
                     }
-                    buffer.get(ebs.getBlockMSBArray().data);
+                    buffer.get(subChunk.getBlockMSBArray().data);
                 } else {
-                    ebs.setBlockMSBArray(null);
+                    subChunk.setBlockMSBArray(null);
                 }
             }
         }
     }
 
     @Override
-    public boolean sectionPrivilegedAccess() {
+    public boolean subChunkPrivilegedAccess() {
         return true;
     }
 
     @Override
-    public void writeSectionToNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
-        section.setByteArray("Blocks", ebs.getBlockLSBArray());
+    public void writeSubChunkToNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        nbt.setByteArray("Blocks", subChunk.getBlockLSBArray());
 
-        if (ebs.getBlockMSBArray() != null) {
-            section.setByteArray("Add", ebs.getBlockMSBArray().data);
+        if (subChunk.getBlockMSBArray() != null) {
+            nbt.setByteArray("Add", subChunk.getBlockMSBArray().data);
         }
     }
 
     @Override
-    public void readSectionFromNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
-        ebs.setBlockLSBArray(section.getByteArray("Blocks"));
+    public void readSubChunkFromNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        subChunk.setBlockLSBArray(nbt.getByteArray("Blocks"));
 
-        if (section.hasKey("Add", 7)) {
-            ebs.setBlockMSBArray(new NibbleArray(section.getByteArray("Add"), 4));
+        if (nbt.hasKey("Add", 7)) {
+            subChunk.setBlockMSBArray(new NibbleArray(nbt.getByteArray("Add"), 4));
         }
     }
+
+    @Override
+    public void cloneSubChunk(Chunk fromChunk, ExtendedBlockStorage from, ExtendedBlockStorage to) {
+        to.setBlockLSBArray(ArrayUtil.copyArray(from.getBlockLSBArray(), to.getBlockLSBArray()));
+        to.setBlockMSBArray(ArrayUtil.copyArray(from.getBlockMSBArray(), to.getBlockMSBArray()));
+    }
+
+    @Override
+    public void writeBlockToPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet) {
+    }
+
+    @Override
+    public void readBlockFromPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet) {
+
+    }
+
+    @Override
+    public void writeBlockPacketToBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException {
+        buffer.writeShort(Block.getIdFromBlock(packet.field_148883_d) & 0xFFF);
+    }
+
+    @Override
+    public void readBlockPacketFromBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException {
+        packet.field_148883_d = Block.getBlockById(buffer.readUnsignedShort() & 0xFFF);
+    }
 }

src/main/java/com/falsepattern/chunk/internal/vanilla/BlocklightManager.java

@@ -1,28 +1,43 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.vanilla;
 
-import com.falsepattern.chunk.api.ChunkDataManager;
+import com.falsepattern.chunk.api.ArrayUtil;
+import com.falsepattern.chunk.api.DataManager;
 
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.NibbleArray;
 import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
-public class BlocklightManager extends NibbleManager implements ChunkDataManager.SectionNBTDataManager {
+public class BlocklightManager extends NibbleManager implements DataManager.SubChunkDataManager {
     @Override
-    protected NibbleArray getNibbleArray(ExtendedBlockStorage ebs) {
-        return ebs.getBlocklightArray();
+    protected NibbleArray getNibbleArray(ExtendedBlockStorage subChunk) {
+        return subChunk.getBlocklightArray();
     }
 
     @Override
@@ -31,17 +46,22 @@ public class BlocklightManager extends NibbleManager implements ChunkDataManager
     }
 
     @Override
-    public boolean sectionPrivilegedAccess() {
+    public boolean subChunkPrivilegedAccess() {
         return true;
     }
 
     @Override
-    public void writeSectionToNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
-        section.setByteArray("BlockLight", ebs.getBlocklightArray().data);
+    public void writeSubChunkToNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        nbt.setByteArray("BlockLight", subChunk.getBlocklightArray().data);
     }
 
     @Override
-    public void readSectionFromNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
-        ebs.setBlocklightArray(new NibbleArray(section.getByteArray("BlockLight"), 4));
+    public void readSubChunkFromNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        subChunk.setBlocklightArray(new NibbleArray(nbt.getByteArray("BlockLight"), 4));
+    }
+
+    @Override
+    public void cloneSubChunk(Chunk fromChunk, ExtendedBlockStorage from, ExtendedBlockStorage to) {
+        from.setBlocklightArray(ArrayUtil.copyArray(from.getBlocklightArray(), to.getBlocklightArray()));
     }
 }

src/main/java/com/falsepattern/chunk/internal/vanilla/LightingManager.java

@@ -0,0 +1,63 @@
+/*
+ * ChunkAPI
+ *
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
+ *
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
+ */
+
+package com.falsepattern.chunk.internal.vanilla;
+
+import com.falsepattern.chunk.api.ArrayUtil;
+import com.falsepattern.chunk.api.DataManager;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.chunk.Chunk;
+
+public class LightingManager extends VanillaManager implements DataManager.ChunkDataManager {
+    @Override
+    public String id() {
+        return "lighting";
+    }
+
+    @Override
+    public void writeChunkToNBT(Chunk chunk, NBTTagCompound nbt) {
+        nbt.setIntArray("HeightMap", chunk.heightMap);
+        nbt.setBoolean("LightPopulated", chunk.isLightPopulated);
+    }
+
+    @Override
+    public void readChunkFromNBT(Chunk chunk, NBTTagCompound nbt) {
+        chunk.heightMap = nbt.getIntArray("HeightMap");
+        chunk.isLightPopulated = nbt.getBoolean("LightPopulated");
+    }
+
+    @Override
+    public boolean chunkPrivilegedAccess() {
+        return true;
+    }
+
+    @Override
+    public void cloneChunk(Chunk from, Chunk to) {
+        to.heightMap = ArrayUtil.copyArray(from.heightMap, to.heightMap);
+        to.isLightPopulated = from.isLightPopulated;
+    }
+}

src/main/java/com/falsepattern/chunk/internal/vanilla/MetadataManager.java

@@ -1,28 +1,49 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.vanilla;
 
-import com.falsepattern.chunk.api.ChunkDataManager;
+import com.falsepattern.chunk.api.ArrayUtil;
+import com.falsepattern.chunk.api.DataManager;
 
 import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.S23PacketBlockChange;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.NibbleArray;
 import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
-public class MetadataManager extends NibbleManager implements ChunkDataManager.SectionNBTDataManager {
+import java.io.IOException;
+
+public class MetadataManager extends NibbleManager implements
+        DataManager.BlockPacketDataManager,
+        DataManager.SubChunkDataManager {
     @Override
-    protected NibbleArray getNibbleArray(ExtendedBlockStorage ebs) {
-        return ebs.getMetadataArray();
+    protected NibbleArray getNibbleArray(ExtendedBlockStorage subChunk) {
+        return subChunk.getMetadataArray();
     }
 
     @Override
@@ -31,17 +52,40 @@ public class MetadataManager extends NibbleManager implements ChunkDataManager.S
     }
 
     @Override
-    public boolean sectionPrivilegedAccess() {
+    public boolean subChunkPrivilegedAccess() {
         return true;
     }
 
     @Override
-    public void writeSectionToNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
-        section.setByteArray("Data", ebs.getMetadataArray().data);
+    public void writeSubChunkToNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        nbt.setByteArray("Data", subChunk.getMetadataArray().data);
     }
 
     @Override
-    public void readSectionFromNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
-        ebs.setBlockMetadataArray(new NibbleArray(section.getByteArray("Data"), 4));
+    public void readSubChunkFromNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
+        subChunk.setBlockMetadataArray(new NibbleArray(nbt.getByteArray("Data"), 4));
+    }
+
+    @Override
+    public void cloneSubChunk(Chunk fromChunk, ExtendedBlockStorage from, ExtendedBlockStorage to) {
+        to.setBlockMetadataArray(ArrayUtil.copyArray(from.getMetadataArray(), to.getMetadataArray()));
+    }
+
+    @Override
+    public void writeBlockToPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet) {
+    }
+
+    @Override
+    public void readBlockFromPacket(Chunk chunk, int x, int y, int z, S23PacketBlockChange packet) {
+    }
+
+    @Override
+    public void writeBlockPacketToBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException {
+        buffer.writeByte(packet.field_148884_e & 0xF);
+    }
+
+    @Override
+    public void readBlockPacketFromBuffer(S23PacketBlockChange packet, PacketBuffer buffer) throws IOException {
+        packet.field_148884_e = buffer.readUnsignedByte() & 0xF;
     }
 }

src/main/java/com/falsepattern/chunk/internal/vanilla/NibbleManager.java

@@ -1,18 +1,32 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.vanilla;
 
-import com.falsepattern.chunk.api.ChunkDataManager;
+import com.falsepattern.chunk.api.DataManager;
 import com.falsepattern.chunk.internal.Common;
 import lombok.val;
 
@@ -22,37 +36,37 @@ import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
 import java.nio.ByteBuffer;
 
-public abstract class NibbleManager extends VanillaManager implements ChunkDataManager.PacketDataManager {
-    public static final int BYTES_PER_EBS = Common.BLOCKS_PER_EBS / 2;
+public abstract class NibbleManager extends VanillaManager implements DataManager.PacketDataManager {
+    public static final int BYTES_PER_SUBCHUNK = Common.BLOCKS_PER_SUBCHUNK / 2;
 
-    protected abstract NibbleArray getNibbleArray(ExtendedBlockStorage ebs);
+    protected abstract NibbleArray getNibbleArray(ExtendedBlockStorage subChunk);
 
     @Override
     public int maxPacketSize() {
-        return Common.EBS_PER_CHUNK * BYTES_PER_EBS;
+        return Common.SUBCHUNKS_PER_CHUNK * BYTES_PER_SUBCHUNK;
     }
 
     @Override
-    public void writeToBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer data) {
-        val ebsArray = chunk.getBlockStorageArray();
-        for (int i = 0; i < ebsArray.length; i++) {
-            if ((ebsMask & (1 << i)) != 0) {
-                val ebs = ebsArray[i];
-                if (ebs != null) {
-                    data.put(getNibbleArray(ebs).data, 0, BYTES_PER_EBS);
+    public void writeToBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer) {
+        val subChunks = chunk.getBlockStorageArray();
+        for (int i = 0; i < subChunks.length; i++) {
+            if ((subChunkMask & (1 << i)) != 0) {
+                val subChunk = subChunks[i];
+                if (subChunk != null) {
+                    buffer.put(getNibbleArray(subChunk).data, 0, BYTES_PER_SUBCHUNK);
                 }
             }
         }
     }
 
     @Override
-    public void readFromBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer buffer) {
-        val ebsArray = chunk.getBlockStorageArray();
-        for (int i = 0; i < ebsArray.length; i++) {
-            if ((ebsMask & (1 << i)) != 0) {
-                val ebs = ebsArray[i];
-                if (ebs != null) {
-                    buffer.get(getNibbleArray(ebs).data, 0, BYTES_PER_EBS);
+    public void readFromBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer) {
+        val subChunks = chunk.getBlockStorageArray();
+        for (int i = 0; i < subChunks.length; i++) {
+            if ((subChunkMask & (1 << i)) != 0) {
+                val subChunk = subChunks[i];
+                if (subChunk != null) {
+                    buffer.get(getNibbleArray(subChunk).data, 0, BYTES_PER_SUBCHUNK);
                 }
             }
         }

src/main/java/com/falsepattern/chunk/internal/vanilla/SkylightManager.java

@@ -1,18 +1,33 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.vanilla;
 
-import com.falsepattern.chunk.api.ChunkDataManager;
+import com.falsepattern.chunk.api.ArrayUtil;
+import com.falsepattern.chunk.api.DataManager;
 
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.world.chunk.Chunk;
@@ -21,49 +36,58 @@ import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
 import java.nio.ByteBuffer;
 
-public class SkylightManager extends NibbleManager implements ChunkDataManager.SectionNBTDataManager {
+public class SkylightManager extends NibbleManager implements DataManager.SubChunkDataManager {
     @Override
     public String id() {
         return "skylight";
     }
 
     @Override
-    protected NibbleArray getNibbleArray(ExtendedBlockStorage ebs) {
-        return ebs.getSkylightArray();
+    protected NibbleArray getNibbleArray(ExtendedBlockStorage subChunk) {
+        return subChunk.getSkylightArray();
     }
 
     @Override
-    public void writeToBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer data) {
+    public void writeToBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer) {
         if (!chunk.worldObj.provider.hasNoSky) {
-            super.writeToBuffer(chunk, ebsMask, forceUpdate, data);
+            super.writeToBuffer(chunk, subChunkMask, forceUpdate, buffer);
         }
     }
 
     @Override
-    public void readFromBuffer(Chunk chunk, int ebsMask, boolean forceUpdate, ByteBuffer buffer) {
+    public void readFromBuffer(Chunk chunk, int subChunkMask, boolean forceUpdate, ByteBuffer buffer) {
         if (!chunk.worldObj.provider.hasNoSky) {
-            super.readFromBuffer(chunk, ebsMask, forceUpdate, buffer);
+            super.readFromBuffer(chunk, subChunkMask, forceUpdate, buffer);
         }
     }
 
     @Override
-    public boolean sectionPrivilegedAccess() {
+    public boolean subChunkPrivilegedAccess() {
         return true;
     }
 
     @Override
-    public void writeSectionToNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
+    public void writeSubChunkToNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
         if (!chunk.worldObj.provider.hasNoSky) {
-            section.setByteArray("SkyLight", ebs.getSkylightArray().data);
+            nbt.setByteArray("SkyLight", subChunk.getSkylightArray().data);
         } else {
-            section.setByteArray("SkyLight", new byte[ebs.getBlocklightArray().data.length]);
+            nbt.setByteArray("SkyLight", new byte[subChunk.getBlocklightArray().data.length]);
         }
     }
 
     @Override
-    public void readSectionFromNBT(Chunk chunk, ExtendedBlockStorage ebs, NBTTagCompound section) {
+    public void readSubChunkFromNBT(Chunk chunk, ExtendedBlockStorage subChunk, NBTTagCompound nbt) {
         if (!chunk.worldObj.provider.hasNoSky) {
-            ebs.setSkylightArray(new NibbleArray(section.getByteArray("SkyLight"), 4));
+            subChunk.setSkylightArray(new NibbleArray(nbt.getByteArray("SkyLight"), 4));
+        }
+    }
+
+    @Override
+    public void cloneSubChunk(Chunk fromChunk, ExtendedBlockStorage from, ExtendedBlockStorage to) {
+        if (!fromChunk.worldObj.provider.hasNoSky) {
+            to.setSkylightArray(ArrayUtil.copyArray(from.getSkylightArray(), to.getSkylightArray()));
+        } else {
+            to.setSkylightArray(null);
         }
     }
 }

src/main/java/com/falsepattern/chunk/internal/vanilla/VanillaManager.java

@@ -1,22 +1,54 @@
 /*
- * -------------------------------------------------------------------------------
- * @author FalsePattern
+ * ChunkAPI
  *
- * Copyright 2023
+ * Copyright (C) 2023-2024 FalsePattern
+ * All Rights Reserved
  *
- * All rights reserved.
- * Distribution of the software in any form is only allowed with
- * explicit, prior permission from the owner.
- * -------------------------------------------------------------------------------
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This program comes with additional permissions according to Section 7 of the
+ * GNU Affero General Public License. See the full LICENSE file for details.
  */
 
 package com.falsepattern.chunk.internal.vanilla;
 
-import com.falsepattern.chunk.api.ChunkDataManager;
+import com.falsepattern.chunk.api.DataManager;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
-public abstract class VanillaManager implements ChunkDataManager {
+public abstract class VanillaManager implements DataManager {
     @Override
     public String domain() {
         return "minecraft";
     }
+
+    public @NotNull String version() {
+        return "";
+    }
+
+    public @Nullable String newInstallDescription() {
+        return null;
+    }
+
+    public @NotNull String uninstallMessage() {
+        return "";
+    }
+
+    public @Nullable String versionChangeMessage(String priorVersion) {
+        return null;
+    }
 }

src/main/resources/LICENSE

@@ -1,63 +1,746 @@
-#-------------------------------------------------------------------------------
-# @author FalsePattern
-#
-# Copyright 2023
-#
-# All rights reserved.
-# Distribution of the software in any form is only allowed with
-# explicit, prior permission from the owner.
-#-------------------------------------------------------------------------------
-@author FalsePattern
+ChunkAPI
 
+Copyright (C) 2023-2024 FalsePattern
+All Rights Reserved
 
-This code is the property of and owned and copyrighted by FalsePattern.
-This code is provided under a modified visible-source license
-that is as follows:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions of the Software.
 
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
 
-API Code:
-==============================
-API code is identifiable as being in an "API" package in the respective
-repository or mod, and is intended to allow some level of inter-mod
-interactions without creating hard dependencies on the mod proper. This code
-is exempt from the below restrictions for "Mod Code", as it by nature will
-require some level of copying and redistribution.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
 
-The only restrictions imposed on API code are that it remain clearly marked
-with its original authorship and source, that it be used for the purpose
-described previously, and that it not be modified from the original without
-first contacting FalsePattern.
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+This program comes with additional permissions according to Section 7 of the
+GNU Affero General Public License. See the full LICENSE file for details.
+-------------------------------------------------------------------------------
+According to Section 7 of the GNU Affero General Public License, this mod
+comes with the following additional permissions, as well as a possibility of
+re-licensing in case the official version is abandoned for an extended period
+of time:
 
-Mod Code:
-==============================
-Any and all users are permitted to use the source for educational purposes,
-or to create derivative works for private use only. GitHub forks and direct
-downloads are considered derivative works.
+A. Definitions.
+"The Game" refers to Minecraft: Java Edition and its dependencies, developed
+by Mojang Studios, as well as all of its former releases under the name
+Minecraft.
 
-Unless given explicit written permission - verifiable electronic writing is
-acceptable - no user may redistribute this source code nor any derivative
-works. These pre-approved works must prominently contain this copyright notice.
+"Mod" refers to a third-party modification for The Game.
 
-Derivative mods using any or all of the source code or assets are
-EXPRESSLY FORBIDDEN.
+"Modpack" refers to a collection of Mods, which may be independent of
+each other, or connected through various linking mechanisms.
 
-Additionally, no attempt may be made to achieve monetary gain from this code
-by anyone except the original author. In the case of pre-approved derivative
-works, any monetary gains made will be shared between the original author and
-the other developer(s), proportional to the ratio of derived to original code.
+"This Mod" refers to ChunkAPI.
 
-Finally, any and all displays, duplicates or derivatives of this code must be
-prominently marked as such, and must contain attribution to the original
-author, including a link to the original source. Any attempts to claim credit
-for this code will be treated as intentional theft.
+"API" refers to the part of This Mod that is designed to be linked against
+by other Mods.
 
-Due to the Mojang and Minecraft Mod Terms of Service and Licensing
-Restrictions, compiled versions of this code must be provided for free.
-However, with the exception of pre-approved derivative works, only the original
-author's modpacks may distribute compiled binary versions of this code.
+B. Additional Permissions.
 
-==============================
+You may link This Mod against the proprietary code of The Game, as well as
+distribute binary builds of it as part of a Modpack without the AGPL
+restrictions spreading to any other files in that Modpack.
 
-Failure to comply with these restrictions is a violation of copyright law and
-will be dealt with accordingly.
+You may also develop any Mod that depends on the API of This Mod and
+distribute that mod under terms of your own choice. Note that this specific
+permission does not apply to anything not explicitly specified as the API, as
+those are internal implementation details of This Mod, and as such are not
+designed to be used in any third-party Mod, thus the full force of the AGPL
+applies to such code.
+
+C. Termination of Additional Permissions.
+
+The additional permissions from Section B get removed from your copy of This
+Mod if you modify, extend, rename, remove, or in any other way alter any part
+of the public API code, save data formats, or network protocols in
+such a way that it is not perfectly compatible with the official versions of
+This Mod.
+
+If you wish to make modifications to the previously mentioned features, you must
+contribute those modifications back to the maintainers of the official versions
+of This Mod, and once those changes have been integrated and published in an
+official release, your modified version is once again covered by the terms of
+section B.
+
+D. Protections and Abandonment.
+
+To avoid upstream API changes triggering violations of Section C, these
+permissions are valid as long as your modified version of This Mod is perfectly
+compatible with any current or past public release of the official versions of
+This Mod.
+
+In case the official version of This Mod has been completely abandoned by
+the maintainer(s) for 1 whole year with no intent of future updates given
+by said maintainers, modified versions of This Mod may be freely re-licensed
+to the GNU Lesser General Public License (LGPL), version 3.0 or later,
+without any of the additional terms imposed by the
+GNU Affero General Public License.
+-------------------------------------------------------------------------------
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

src/main/resources/META-INF/chunkapi_at.cfg

@@ -0,0 +1,4 @@
+public-f net.minecraft.world.chunk.NibbleArray field_76585_a # data
+public-f net.minecraft.world.chunk.NibbleArray field_76583_b # depthBits
+public-f net.minecraft.world.chunk.NibbleArray field_76584_c # depthBitsPlusFour
+public net.minecraft.server.management.PlayerManager$PlayerInstance