Exclude CODEOWNERS from language statistics

Add CODEOWNERS (one staff approval)
Compatibility with TrueOG fork of Purpur (RocksDB playerdata)
2026-10-27 08:25:14 -04:00 · 2026-10-27 08:25:14 -04:00 · 2026-10-17 15:11:50 -04:00 · 2026-10-02 11:52:10 -04:00 · 2026-05-18 12:01:43 -04:00 · 2026-03-30 12:20:36 -04:00
82 changed files with 7640 additions and 5000 deletions
@@ -0,0 +1 @@
+.gitea/CODEOWNERS linguist-detectable=false
@@ -0,0 +1,3 @@
+# Pull requests request review from the eligible staff team(s).
+# One approval from either an Admin or Developer satisfies branch protection.
+*   @trueog/Admins @trueog/Developers
@@ -1,76 +0,0 @@
-name: OpenInv CI
-
-on:
-  push:
-  pull_request_target:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v2
-
-      - name: Set Up Java
-        uses: actions/setup-java@v1
-        with:
-          java-version: 16
-
-      # Use cache to speed up build
-      - name: Cache Maven Repo
-        uses: actions/cache@v2
-        id: cache
-        with:
-          path: ~/.m2/repository
-          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
-
-      # Install Spigot dependencies.
-      # This script uses Maven to check all required installations and ensure that they are present.
-      - name: Install Spigot Dependencies
-        run: . scripts/install_spigot_dependencies.sh
-
-      - name: Build With Maven
-        run: mvn -e clean package -am -P all
-
-      # Upload artifacts
-      - name: Upload Distributable Jar
-        id: upload-final
-        uses: actions/upload-artifact@v2
-        with:
-          name: dist
-          path: ./target/OpenInv.jar
-      - name: Upload API Jar
-        id: upload-api
-        uses: actions/upload-artifact@v2
-        with:
-          name: api
-          path: ./api/target/openinvapi*.jar
-
-  release:
-    name: Create Github Release
-    needs: [ build ]
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Set Release Variables
-        run: bash ./scripts/set_release_env.sh
-
-      - name: Download Artifacts
-        uses: actions/download-artifact@v2
-
-      - name: Create Release
-        id: create-release
-        uses: softprops/action-gh-release@v0.1.5
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          name: ${{ env.VERSIONED_NAME }}
-          body: ${{ env.GENERATED_CHANGELOG }}
-          draft: true
-          prerelease: false
-          files: ./dist/OpenInv.jar
@@ -1,37 +0,0 @@
-name: Release to CurseForge
-
-on:
-  release:
-    types: [ released ]
-
-jobs:
-  curseforge_release:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Fetch Github Release Asset
-        uses: dsaltares/fetch-gh-release-asset@0.0.5
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          version: ${{ github.event.release.id }}
-          file: OpenInv.jar
-
-      - name: Set CurseForge Variables
-        run: . scripts/set_curseforge_env.sh "${{ github.event.release.body }}"
-
-      - name: Create CurseForge Release
-        uses: itsmeow/curseforge-upload@v3
-        with:
-          token: ${{ secrets.CURSEFORGE_TOKEN }}
-          project_id: 31432
-          game_endpoint: minecraft
-          file_path: ./OpenInv.jar
-          display_name: "${{ github.event.release.name }}"
-          game_versions: "${{ env.CURSEFORGE_MINECRAFT_VERSIONS }}"
-          release_type: release
-          changelog_type: markdown
-          changelog: "${{ env.CURSEFORGE_CHANGELOG }}"
@@ -4,7 +4,9 @@
 **/.idea/
 **.iml
 **/target/
+**/build/
 **/bin/
 **/out/
+**/.gradle/
 **/dependency-reduced-pom.xml
 **/pom.xml.versionsBackup
@@ -124,22 +124,10 @@ The OpenInv API is available via [JitPack](https://jitpack.io/).
 ```

 ### Compilation
-To compile, the relevant Spigot jars must be installed in your local repository using the `install` plugin:
-```shell
-mvn install:install-file -Dpackaging=jar -Dfile=spigot-1.8-R0.1-SNAPSHOT.jar \
-    -DgroupId=org.spigotmc -DartifactId=spigot -Dversion=1.8-R0.1-SNAPSHOT
-```
-Note that BuildTools automatically installs produced files. If you use BuildTools to compile Spigot locally, you don't need to install it manually.  
-If you want to use Paper as a dependency, you can install it by executing PaperClip with the property `paperclip.install` set to true:
-```shell
-wget -O paperclip.jar https://papermc.io/api/v1/paper/1.16.5/latest/download
-java -jar -Dpaperclip.install=true paperclip.jar
-```
+OpenInv now builds with Gradle 8.14.3 using Paperweight userdev for Purpur `1.19.4` on Java 17 / GraalVM 17.

-To compile for a single version, specify the NMS revision you are targeting: `mvn -pl <NMS module> -am clean install`
+Build the plugin with:
+`./gradlew build`

-To compile for a set of versions, you'll need to use a profile. The only provided profile is `all`. Select a profile using the `-P` argument: `mvn clean package -am -P all`
-
-For more information, check out the [official Maven guide](http://maven.apache.org/guides/introduction/introduction-to-profiles.html).
-
-The final file is `target/OpenInv.jar`
+The server-ready shaded jar is written to:
+`build/libs/OpenInv-${version}.jar`
@@ -1,49 +0,0 @@
-<!--
-  ~ Copyright (C) 2011-2021 lishid. All rights reserved.
-  ~
-  ~ This program is free software: you can redistribute it and/or modify
-  ~ it under the terms of the GNU General Public License as published by
-  ~ the Free Software Foundation, version 3.
-  ~
-  ~ 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 General Public License for more details.
-  ~
-  ~ You should have received a copy of the GNU General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <artifactId>openinvparent</artifactId>
-    <groupId>com.lishid</groupId>
-    <version>4.1.9-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>openinvapi</artifactId>
-  <name>OpenInvAPI</name>
-
-  <dependencies>
-    <dependency>
-      <artifactId>annotations</artifactId>
-      <groupId>org.jetbrains</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>spigot-api</artifactId>
-      <groupId>org.spigotmc</groupId>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
-
-</project>
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,9 +22,7 @@ import com.lishid.openinv.internal.ISpecialEnderChest;
 import com.lishid.openinv.internal.ISpecialInventory;
 import com.lishid.openinv.internal.ISpecialPlayerInventory;
 import com.lishid.openinv.util.InventoryAccess;
-import com.lishid.openinv.util.StringMetric;
 import java.util.UUID;
-import java.util.logging.Level;
 import java.util.logging.Logger;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
@@ -36,272 +34,254 @@ import org.jetbrains.annotations.Nullable;

 /**
 * Interface defining behavior for the OpenInv plugin.
- *
- * @author Jikoo
 */
 public interface IOpenInv {

    /**
-     * Check the configuration value for whether or not OpenInv saves player data when unloading
-     * players. This is exclusively for users who do not allow editing of inventories, only viewing,
-     * and wish to prevent any possibility of bugs such as lishid#40. If true, OpenInv will not ever
-     * save any edits made to players.
-     *
-     * @return false unless configured otherwise
-     */
-    boolean disableSaving();
-
-    /**
-     * Gets the active ISilentContainer implementation.
-     *
-     * @return the ISilentContainer
-     * @throws IllegalStateException if the server version is unsupported
-     */
-    @NotNull IAnySilentContainer getAnySilentContainer();
-
-    /**
-     * Gets the active IInventoryAccess implementation.
-     *
-     * @return the IInventoryAccess
-     * @throws IllegalStateException if the server version is unsupported
-     */
-    @Deprecated
-    default @NotNull IInventoryAccess getInventoryAccess() {
-        return new InventoryAccess();
-    }
-
-    /**
-     * Gets the provided player's AnyChest setting.
-     *
-     * @param player the OfflinePlayer
-     * @return true if AnyChest is enabled
-     * @throws IllegalStateException if the server version is unsupported
-     */
-    boolean getPlayerAnyChestStatus(@NotNull OfflinePlayer player);
-
-    /**
-     * Gets a unique identifier by which the OfflinePlayer can be referenced. Using the value
-     * returned to look up a Player will generally be much faster for later implementations.
-     *
-     * @param offline the OfflinePlayer
-     * @return the identifier
-     * @throws IllegalStateException if the server version is unsupported
-     */
-    default @NotNull String getPlayerID(@NotNull OfflinePlayer offline) {
-        return offline.getUniqueId().toString();
-    }
-
-    /**
-     * Gets a player's SilentChest setting.
-     *
-     * @param offline the OfflinePlayer
-     * @return true if SilentChest is enabled
-     * @throws IllegalStateException if the server version is unsupported
-     */
-    boolean getPlayerSilentChestStatus(@NotNull OfflinePlayer offline);
-
-    /**
-     * Gets an ISpecialEnderChest for the given Player.
-     *
-     * @param player the Player
-     * @param online true if the Player is currently online
-     * @return the ISpecialEnderChest
-     * @throws IllegalStateException  if the server version is unsupported
-     * @throws InstantiationException if the ISpecialEnderChest could not be instantiated
-     */
-    @NotNull ISpecialEnderChest getSpecialEnderChest(@NotNull Player player, boolean online) throws InstantiationException;
-
-    /**
-     * Gets an ISpecialPlayerInventory for the given Player.
-     *
-     * @param player the Player
-     * @param online true if the Player is currently online
-     * @return the ISpecialPlayerInventory
-     * @throws IllegalStateException  if the server version is unsupported
-     * @throws InstantiationException if the ISpecialPlayerInventory could not be instantiated
-     */
-    @NotNull ISpecialPlayerInventory getSpecialInventory(@NotNull Player player, boolean online) throws InstantiationException;
-
-    /**
-     * Checks if the server version is supported by OpenInv.
+     * Check if the server version is supported by OpenInv.
     *
     * @return true if the server version is supported
     */
    boolean isSupportedVersion();

    /**
-     * Load a Player from an OfflinePlayer. May return null under some circumstances.
+     * Check the configuration value for whether OpenInv saves player data when unloading players. This is exclusively
+     * for users who do not allow editing of inventories, only viewing, and wish to prevent any possibility of bugs such
+     * as lishid#40. If true, OpenInv will not ever save any edits made to players.
     *
-     * @param offline the OfflinePlayer to load a Player for
-     * @return the Player, or null
+     * @return false unless configured otherwise
+     */
+    boolean disableSaving();
+
+    /**
+     * Check the configuration value for whether OpenInv allows offline access. If true, OpenInv will not load or allow
+     * modification of players while they are not online. This does not prevent other plugins from using existing loaded
+     * players who have gone offline.
+     *
+     * @return false unless configured otherwise
+     * @since 4.2.0
+     */
+    boolean disableOfflineAccess();
+
+    /**
+     * Check the configuration value for whether OpenInv uses history for opening commands. If false, OpenInv will use
+     * the previous parameterized search when no parameters are provided.
+     *
+     * @return false unless configured otherwise
+     * @since 4.3.0
+     */
+    boolean noArgsOpensSelf();
+
+    /**
+     * Get the active {@link IAnySilentContainer} implementation.
+     *
+     * @return the active implementation for the server version
+     * @throws IllegalStateException if the server version is unsupported
+     */
+    @NotNull IAnySilentContainer getAnySilentContainer();
+
+    /**
+     * @deprecated Use static {@link InventoryAccess} methods.
+     */
+    @Deprecated(forRemoval = true)
+    default @NotNull IInventoryAccess getInventoryAccess() {
+        return new InventoryAccess();
+    }
+
+    /**
+     * @deprecated Use {@link #getAnyContainerStatus(OfflinePlayer)}. Not all containers are chests.
+     */
+    @Deprecated(forRemoval = true, since = "4.2.0")
+    default boolean getPlayerAnyChestStatus(@NotNull OfflinePlayer offline) {
+        return getAnyContainerStatus(offline);
+    }
+
+    /**
+     * Get whether a user has AnyContainer mode enabled.
+     *
+     * @param offline the user to obtain the state of
+     * @return true if AnyContainer mode is enabled
+     */
+    boolean getAnyContainerStatus(@NotNull OfflinePlayer offline);
+
+    /**
+     * @deprecated Use {@link #setAnyContainerStatus(OfflinePlayer, boolean)}. Not all containers are chests.
+     */
+    @Deprecated(forRemoval = true, since = "4.2.0")
+    default void setPlayerAnyChestStatus(@NotNull OfflinePlayer offline, boolean status) {
+        setAnyContainerStatus(offline, status);
+    }
+
+    /**
+     * Set whether a user has AnyContainer mode enabled.
+     *
+     * @param offline the user to set the state of
+     * @param status the state of the mode
+     */
+    void setAnyContainerStatus(@NotNull OfflinePlayer offline, boolean status);
+
+    /**
+     * @deprecated Use {@link #getSilentContainerStatus(OfflinePlayer)}. Not all containers are chests.
+     */
+    @Deprecated(forRemoval = true, since = "4.2.0")
+    default boolean getPlayerSilentChestStatus(@NotNull OfflinePlayer offline) {
+        return getSilentContainerStatus(offline);
+    }
+
+    /**
+     * Get whether a user has SilentContainer mode enabled.
+     *
+     * @param offline the user to obtain the state of
+     * @return true if SilentContainer mode is enabled
+     */
+    boolean getSilentContainerStatus(@NotNull OfflinePlayer offline);
+
+    /**
+     * @deprecated Use {@link #setSilentContainerStatus(OfflinePlayer, boolean)}. Not all containers are chests.
+     */
+    @Deprecated(forRemoval = true, since = "4.2.0")
+    default void setPlayerSilentChestStatus(@NotNull OfflinePlayer offline, boolean status) {
+        setSilentContainerStatus(offline, status);
+    }
+
+    /**
+     * Set whether a user has SilentContainer mode enabled.
+     *
+     * @param offline the user to set the state of
+     * @param status the state of the mode
+     */
+    void setSilentContainerStatus(@NotNull OfflinePlayer offline, boolean status);
+
+    /**
+     * Get a unique identifier by which the OfflinePlayer can be referenced.
+     *
+     * @deprecated Use {@link OfflinePlayer#getUniqueId()} and {@link UUID#toString()}. This was necessary for non-UUID
+     * versions of Minecraft, but support for them has been dropped for years.
+     * @param offline the OfflinePlayer
+     * @return the identifier
+     * @throws IllegalStateException if the server version is unsupported
+     */
+    @Deprecated(forRemoval = true)
+    default @NotNull String getPlayerID(@NotNull OfflinePlayer offline) {
+        return offline.getUniqueId().toString();
+    }
+
+    /**
+     * Get an {@link ISpecialEnderChest} for a user.
+     *
+     * @param player the {@link Player} owning the inventory
+     * @param online whether the owner is currently online
+     * @return the created inventory
+     * @throws IllegalStateException if the server version is unsupported
+     * @throws InstantiationException if there was an issue creating the inventory
+     */
+    @NotNull ISpecialEnderChest getSpecialEnderChest(@NotNull Player player, boolean online) throws InstantiationException;
+
+    /**
+     * Get an {@link ISpecialPlayerInventory} for a user.
+     *
+     * @param player the {@link Player} owning the inventory
+     * @param online whether the owner is currently online
+     * @return the created inventory
+     * @throws IllegalStateException if the server version is unsupported
+     * @throws InstantiationException if there was an issue creating the inventory
+     */
+    @NotNull ISpecialPlayerInventory getSpecialInventory(@NotNull Player player, boolean online) throws InstantiationException;
+
+    /**
+     * Open an {@link ISpecialInventory} for a {@link Player}.
+     *
+     * @param player the viewer
+     * @param inventory the inventory to open
+     * @return the resulting {@link InventoryView}
+     */
+    @Nullable InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory);
+
+    /**
+     * Check if a {@link Player} is currently loaded by OpenInv.
+     *
+     * @param playerUuid the {@link UUID} of the {@code Player}
+     * @return whether the {@code Player} is loaded
+     * @since 4.2.0
+     */
+    boolean isPlayerLoaded(@NotNull UUID playerUuid);
+
+    /**
+     * Load a {@link Player} from an {@link OfflinePlayer}. If the user has not played before or the default world for
+     * the server is not loaded, this will return {@code null}.
+     *
+     * @param offline the {@code OfflinePlayer} to load a {@code Player} for
+     * @return the loaded {@code Player}
     * @throws IllegalStateException if the server version is unsupported
     */
    @Nullable Player loadPlayer(@NotNull final OfflinePlayer offline);

    /**
-     * Get an OfflinePlayer by name.
-     * <p>
-     * Note: This method is potentially very heavily blocking. It should not ever be called on the
+     * Match an existing {@link OfflinePlayer}. If the name is a {@link UUID#toString() UUID string}, this will only
+     * return the user if they have actually played on the server before, unlike {@link Bukkit#getOfflinePlayer(UUID)}.
+     *
+     * <p>This method is potentially very heavily blocking. It should not ever be called on the
     * main thread, and if it is, a stack trace will be displayed alerting server owners to the
     * call.
     *
-     * @param name the name of the Player
-     * @return the OfflinePlayer with the closest matching name or null if no players have ever logged in
+     * @param name the string to match
+     * @return the user with the closest matching name
     */
-    default @Nullable OfflinePlayer matchPlayer(@NotNull String name) {
-
-        // Warn if called on the main thread - if we resort to searching offline players, this may take several seconds.
-        if (Bukkit.getServer().isPrimaryThread()) {
-            this.getLogger().warning("Call to OpenInv#matchPlayer made on the main thread!");
-            this.getLogger().warning("This can cause the server to hang, potentially severely.");
-            this.getLogger().log(Level.WARNING, new Throwable("Current stack trace"), () -> "Current stack trace");
-        }
-
-        OfflinePlayer player;
-
-        try {
-            UUID uuid = UUID.fromString(name);
-            player = Bukkit.getOfflinePlayer(uuid);
-            // Ensure player is a real player, otherwise return null
-            if (player.hasPlayedBefore() || player.isOnline()) {
-                return player;
-            }
-        } catch (IllegalArgumentException ignored) {
-            // Not a UUID
-        }
-
-        player = Bukkit.getServer().getPlayerExact(name);
-
-        if (player != null) {
-            return player;
-        }
-
-        player = Bukkit.getServer().getOfflinePlayer(name);
-
-        if (player.hasPlayedBefore()) {
-            return player;
-        }
-
-        player = Bukkit.getServer().getPlayer(name);
-
-        if (player != null) {
-            return player;
-        }
-
-        float bestMatch = 0;
-        for (OfflinePlayer offline : Bukkit.getServer().getOfflinePlayers()) {
-            if (offline.getName() == null) {
-                // Loaded by UUID only, name has never been looked up.
-                continue;
-            }
-
-            float currentMatch = StringMetric.compareJaroWinkler(name, offline.getName());
-
-            if (currentMatch == 1.0F) {
-                return offline;
-            }
-
-            if (currentMatch > bestMatch) {
-                bestMatch = currentMatch;
-                player = offline;
-            }
-        }
-
-        // Only null if no players have played ever, otherwise even the worst match will do.
-        return player;
-    }
+    @Nullable OfflinePlayer matchPlayer(@NotNull String name);

    /**
-     * Open an ISpecialInventory for a Player.
-     *
-     * @param player the Player
-     * @param inventory the ISpecialInventory
-     * @return the InventoryView for the opened ISpecialInventory
+     * @deprecated OpenInv uses action bar chat for notifications. Whether they show is based on language settings.
     */
-    @Nullable InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory);
-
-    /**
-     * Check the configuration value for whether or not OpenInv displays a notification to the user
-     * when a container is activated with AnyChest.
-     *
-     * @return true unless configured otherwise
-     * @deprecated OpenInv uses action bar chat for notifications. Whether or not they show is based on language settings.
-     */
-    @Deprecated
+    @Deprecated(forRemoval = true)
    default boolean notifyAnyChest() {
        return true;
    }

    /**
-     * Check the configuration value for whether or not OpenInv displays a notification to the user
-     * when a container is activated with SilentChest.
-     *
-     * @return true unless configured otherwise
-     * @deprecated OpenInv uses action bar chat for notifications. Whether or not they show is based on language settings.
+     * @deprecated OpenInv uses action bar chat for notifications. Whether they show is based on language settings.
     */
-    @Deprecated
+    @Deprecated(forRemoval = true)
    default boolean notifySilentChest() {
        return true;
    }

    /**
-     * Mark a Player as no longer in use by a Plugin to allow OpenInv to remove it from the cache
-     * when eligible.
-     *
-     * @param player the Player
-     * @param plugin the Plugin no longer holding a reference to the Player
-     * @throws IllegalStateException if the server version is unsupported
+     * @deprecated see {@link #retainPlayer(Player, Plugin)}
     */
-    void releasePlayer(@NotNull Player player, @NotNull Plugin plugin);
+    @Deprecated(forRemoval = true, since = "4.2.0")
+    default void releasePlayer(@NotNull Player player, @NotNull Plugin plugin) {}

    /**
-     * Mark a Player as in use by a Plugin to prevent it from being removed from the cache. Used to
-     * prevent issues with multiple copies of the same Player being loaded such as lishid#49.
-     * Changes made to loaded copies overwrite changes to the others when saved, leading to
-     * duplication bugs and more.
-     * <p>
-     * When finished with the Player object, be sure to call {@link #releasePlayer(Player, Plugin)}
-     * to prevent the cache from keeping it stored until the plugin is disabled.
-     * <p>
-     * When using a Player object from OpenInv, you must handle the Player coming online, replacing
-     * your Player reference with the Player from the PlayerJoinEvent. In addition, you must change
-     * any values in the Player to reflect any unsaved alterations to the existing Player which do
-     * not affect the inventory or ender chest contents.
-     * <p>
-     * OpenInv only saves player data when unloading a Player from the cache, and then only if
-     * {@link #disableSaving()} returns false. If you are making changes that OpenInv does not cause
-     * to persist when a Player logs in as noted above, it is suggested that you manually call
-     * {@link Player#saveData()} when releasing your reference to ensure your changes persist.
+     * @deprecated OpenInv no longer uses an internal cache beyond maintaining copies of currently open inventories.
+     * If you wish to use/modify a player, ensure either {@link IOpenInv#isPlayerLoaded(UUID)} is false or the player
+     * instance is the same memory address as the one in use by OpenInv.
+     * <pre>
+     *  public &#64;NotNull Player savePlayerData(&#64;NotNull Player player) {
+     *     IOpenInv openInv = ...
+     *     if (!openInv.disableSaving() && openInv.isPlayerLoaded(player.getUniqueId())) {
+     *         Player openInvLoadedPlayer = openInv.loadPlayer(myInUsePlayer);
+     *         if (openInvLoadedPlayer != player) {
+     *             // The copy loaded by OpenInv is not the same as our loaded copy. Push our changes.
+     *             copyPlayerModifications(player, openInvLoadedPlayer);
+     *         }
+     *         // OpenInv will handle saving data when the player is unloaded.
+     *         // Optionally, to be sure our changes will persist, save now.
+     *         // openInvLoadedPlayer.saveData();
+     *         return openInvLoadedPlayer;
+     *     }
     *
-     * @param player the Player
-     * @param plugin the Plugin holding the reference to the Player
-     * @throws IllegalStateException if the server version is unsupported
+     *     player.saveData();
+     *     return player;
+     * }
+     * </pre>
     */
-    void retainPlayer(@NotNull Player player, @NotNull Plugin plugin);
+    @Deprecated(forRemoval = true, since = "4.2.0")
+    default void retainPlayer(@NotNull Player player, @NotNull Plugin plugin) {}

    /**
-     * Sets a player's AnyChest setting.
+     * Forcibly close inventories of and unload any cached data for a user.
     *
-     * @param offline the OfflinePlayer
-     * @param status the status
-     * @throws IllegalStateException if the server version is unsupported
-     */
-    void setPlayerAnyChestStatus(@NotNull OfflinePlayer offline, boolean status);
-
-    /**
-     * Sets a player's SilentChest setting.
-     *
-     * @param offline the OfflinePlayer
-     * @param status the status
-     * @throws IllegalStateException if the server version is unsupported
-     */
-    void setPlayerSilentChestStatus(@NotNull OfflinePlayer offline, boolean status);
-
-    /**
-     * Forcibly unload a cached Player's data.
-     *
-     * @param offline the OfflinePlayer to unload
-     * @throws IllegalStateException if the server version is unsupported
+     * @param offline the {@link OfflinePlayer} to unload
     */
    void unload(@NotNull OfflinePlayer offline);

@@ -0,0 +1,74 @@
+package com.lishid.openinv.event;
+
+import com.lishid.openinv.internal.ISpecialInventory;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Event fired before OpenInv saves a player's data.
+ */
+public class OpenPlayerSaveEvent extends Event implements Cancellable {
+
+  private static final HandlerList HANDLERS = new HandlerList();
+
+  private final Player player;
+  private final ISpecialInventory inventory;
+  private boolean cancelled = false;
+
+  public OpenPlayerSaveEvent(@NotNull Player player, @NotNull ISpecialInventory inventory) {
+    this.player = player;
+    this.inventory = inventory;
+  }
+
+  /**
+   * Get the {@link Player} whose data is being saved.
+   *
+   * @return player the Player whose data is being saved
+   */
+  public @NotNull Player getPlayer() {
+    return player;
+  }
+
+  /**
+   * Get the {@link ISpecialInventory} that triggered the save by being closed.
+   *
+   * @return the special inventory
+   */
+  public @NotNull ISpecialInventory getInventory() {
+    return inventory;
+  }
+
+  /**
+   * Get whether the event is cancelled.
+   *
+   * @return true if the event is cancelled
+   */
+  @Override
+  public boolean isCancelled() {
+    return cancelled;
+  }
+
+  /**
+   * Set whether the event is cancelled.
+   *
+   * @param cancel whether the event is cancelled
+   */
+  @Override
+  public void setCancelled(boolean cancel) {
+    this.cancelled = cancel;
+  }
+
+  @NotNull
+  @Override
+  public HandlerList getHandlers() {
+    return HANDLERS;
+  }
+
+  public static HandlerList getHandlerList() {
+    return HANDLERS;
+  }
+
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -16,7 +16,6 @@

 package com.lishid.openinv.internal;

-import org.bukkit.Material;
 import org.bukkit.block.Barrel;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
@@ -24,49 +23,48 @@ import org.bukkit.block.BlockState;
 import org.bukkit.block.EnderChest;
 import org.bukkit.block.ShulkerBox;
 import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.Directional;
 import org.bukkit.block.data.type.Chest;
 import org.bukkit.entity.Cat;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.util.BoundingBox;
 import org.jetbrains.annotations.NotNull;

 public interface IAnySilentContainer {

    /**
-     * Opens the container at the given coordinates for the Player. If you do not want blocked
-     * containers to open, be sure to check {@link #isAnyContainerNeeded(Player, Block)}
-     * first.
+     * Forcibly open the container at the given coordinates for the Player. This will open blocked containers! Be sure
+     * to check {@link #isAnyContainerNeeded(Block)} first if that is not desirable.
     *
-     * @param player    the Player opening the container
-     * @param silent    whether the container's noise is to be silenced
-     * @param block     the Block
+     * @param player the {@link Player} opening the container
+     * @param silent whether the container's noise is to be silenced
+     * @param block  the {@link Block} of the container
     * @return true if the container can be opened
     */
    boolean activateContainer(@NotNull Player player, boolean silent, @NotNull Block block);

    /**
-     * Closes the Player's currently open container silently, if necessary.
+     * Perform operations required to close the current container silently.
     *
-     * @param player the Player closing a container
+     * @param player the {@link Player} closing a container
     */
    void deactivateContainer(@NotNull Player player);

    /**
-     * @deprecated use {@link #isAnyContainerNeeded(Block)}
     * @param player the player opening the container
-     * @param block the block
+     * @param block  the {@link Block} of the container
     * @return true if the container is blocked
+     * @deprecated use {@link #isAnyContainerNeeded(Block)}
     */
-    @Deprecated
+    @Deprecated(forRemoval = true, since = "4.1.9")
    default boolean isAnyContainerNeeded(@NotNull Player player, @NotNull Block block) {
        return isAnyContainerNeeded(block);
    }

    /**
-     * Checks if the container at the given coordinates is blocked.
+     * Check if the container at the given coordinates is blocked.
     *
-     * @param block  the Block
+     * @param block the {@link Block} of the container
     * @return true if the container is blocked
     */
    default boolean isAnyContainerNeeded(@NotNull Block block) {
@@ -83,27 +81,12 @@ public interface IAnySilentContainer {
        }

        // Shulker boxes require 1/2 a block clear in the direction they open.
-        if (blockState instanceof ShulkerBox) {
-            BoundingBox boundingBox = block.getBoundingBox();
-            if (boundingBox.getVolume() > 1) {
-                // Shulker box is already open.
-                return false;
-            }
-
-            BlockData blockData = block.getBlockData();
-            if (!(blockData instanceof Directional)) {
-                // Shouldn't be possible. Just in case, demand AnyChest.
+        if (blockState instanceof ShulkerBox shulker) {
+            if (isShulkerBlocked(shulker)) {
                return true;
            }
-
-            Directional directional = (Directional) blockData;
-            BlockFace face = directional.getFacing();
-            boundingBox.shift(face.getDirection());
-            // Return whether or not bounding boxes overlap.
-            return block.getRelative(face, 1).getBoundingBox().overlaps(boundingBox);
        }

-
        if (!(blockState instanceof org.bukkit.block.Chest)) {
            return false;
        }
@@ -113,11 +96,10 @@ public interface IAnySilentContainer {
        }

        BlockData blockData = block.getBlockData();
-        if (!(blockData instanceof Chest) || ((Chest) blockData).getType() == Chest.Type.SINGLE) {
+        if (!(blockData instanceof Chest chest) || ((Chest) blockData).getType() == Chest.Type.SINGLE) {
            return false;
        }

-        Chest chest = (Chest) blockData;
        int ordinal = (chest.getFacing().ordinal() + 4 + (chest.getType() == Chest.Type.RIGHT ? -1 : 1)) % 4;
        BlockFace relativeFace = BlockFace.values()[ordinal];
        org.bukkit.block.Block relative = block.getRelative(relativeFace);
@@ -127,11 +109,10 @@ public interface IAnySilentContainer {
        }

        BlockData relativeData = relative.getBlockData();
-        if (!(relativeData instanceof Chest)) {
+        if (!(relativeData instanceof Chest relativeChest)) {
            return false;
        }

-        Chest relativeChest = (Chest) relativeData;
        if (relativeChest.getFacing() != chest.getFacing()
                || relativeChest.getType() != (chest.getType() == Chest.Type.RIGHT ? Chest.Type.LEFT : Chest.Type.RIGHT)) {
            return false;
@@ -140,26 +121,59 @@ public interface IAnySilentContainer {
        return isChestBlocked(relative);
    }

-    default boolean isChestBlocked(Block chest) {
+    /**
+     * Check if a {@link ShulkerBox} cannot be opened under ordinary circumstances.
+     *
+     * @param shulkerBox the shulker box container
+     * @return whether the container is blocked
+     */
+    boolean isShulkerBlocked(@NotNull ShulkerBox shulkerBox);
+
+    /**
+     * Check if a chest cannot be opened under ordinary circumstances.
+     *
+     * @param chest the chest block
+     * @return whether the container is blocked
+     */
+    default boolean isChestBlocked(@NotNull Block chest) {
        org.bukkit.block.Block relative = chest.getRelative(0, 1, 0);
        return relative.getType().isOccluding()
                || chest.getWorld().getNearbyEntities(BoundingBox.of(relative), entity -> entity instanceof Cat).size() > 0;
    }

    /**
-     * Checks if the given block is a container which can be unblocked or silenced.
+     * Check if the given {@link Block} is a container which can be unblocked or silenced.
     *
-     * @param block the BlockState
-     * @return true if the Block is a supported container
+     * @param block the potential container
+     * @return true if the type is a supported container
     */
    default boolean isAnySilentContainer(@NotNull Block block) {
-        if (block.getType() == Material.ENDER_CHEST) {
-            return true;
-        }
-        BlockState state = block.getState();
-        return state instanceof org.bukkit.block.Chest
-                || state instanceof org.bukkit.block.ShulkerBox
-                || state instanceof org.bukkit.block.Barrel;
+        return isAnySilentContainer(block.getState());
+    }
+
+    /**
+     * Check if the given {@link BlockState} is a container which can be unblocked or silenced.
+     *
+     * @param blockState the potential container
+     * @return true if the type is a supported container
+     */
+    default boolean isAnySilentContainer(@NotNull BlockState blockState) {
+        return blockState instanceof InventoryHolder holder && isAnySilentContainer(holder)
+                || blockState instanceof EnderChest;
+    }
+
+    /**
+     * Check if the given {@link InventoryHolder} is a container which can be unblocked or silenced.
+     *
+     * @param holder the potential container
+     * @return true if the type is a supported container
+     */
+    default boolean isAnySilentContainer(@NotNull InventoryHolder holder) {
+        return holder instanceof org.bukkit.block.EnderChest
+                || holder instanceof org.bukkit.block.Chest
+                || holder instanceof org.bukkit.block.DoubleChest
+                || holder instanceof org.bukkit.block.ShulkerBox
+                || holder instanceof org.bukkit.block.Barrel;
    }

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -16,49 +16,47 @@

 package com.lishid.openinv.internal;

+import com.lishid.openinv.util.InventoryAccess;
 import org.bukkit.inventory.Inventory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

-@Deprecated
+/**
+ * @deprecated Use static {@link InventoryAccess} methods.
+ */
+@Deprecated(forRemoval = true)
 public interface IInventoryAccess {

    /**
-     * Gets an ISpecialEnderChest from an Inventory or null if the Inventory is not backed by an
-     * ISpecialEnderChest.
-     *
-     * @param inventory the Inventory
-     * @return the ISpecialEnderChest or null
+     * @deprecated Use static {@link InventoryAccess} methods.
     */
-    @Deprecated
-    @Nullable ISpecialEnderChest getSpecialEnderChest(@NotNull Inventory inventory);
+    @Deprecated(forRemoval = true)
+    default @Nullable ISpecialEnderChest getSpecialEnderChest(@NotNull Inventory inventory) {
+        return InventoryAccess.getEnderChest(inventory);
+    }

    /**
-     * Gets an ISpecialPlayerInventory from an Inventory or null if the Inventory is not backed by
-     * an ISpecialPlayerInventory.
-     *
-     * @param inventory the Inventory
-     * @return the ISpecialPlayerInventory or null
+     * @deprecated Use static {@link InventoryAccess} methods.
     */
-    @Deprecated
-    @Nullable ISpecialPlayerInventory getSpecialPlayerInventory(@NotNull Inventory inventory);
+    @Deprecated(forRemoval = true)
+    default @Nullable ISpecialPlayerInventory getSpecialPlayerInventory(@NotNull Inventory inventory) {
+        return InventoryAccess.getPlayerInventory(inventory);
+    }

    /**
-     * Check if an Inventory is an ISpecialEnderChest implementation.
-     *
-     * @param inventory the Inventory
-     * @return true if the Inventory is backed by an ISpecialEnderChest
+     * @deprecated Use static {@link InventoryAccess} methods.
     */
-    @Deprecated
-    boolean isSpecialEnderChest(@NotNull Inventory inventory);
+    @Deprecated(forRemoval = true)
+    default boolean isSpecialEnderChest(@NotNull Inventory inventory) {
+        return InventoryAccess.isEnderChest(inventory);
+    }

    /**
-     * Check if an Inventory is an ISpecialPlayerInventory implementation.
-     *
-     * @param inventory the Inventory
-     * @return true if the Inventory is backed by an ISpecialPlayerInventory
+     * @deprecated Use static {@link InventoryAccess} methods.
     */
-    @Deprecated
-    boolean isSpecialPlayerInventory(@NotNull Inventory inventory);
+    @Deprecated(forRemoval = true)
+    default boolean isSpecialPlayerInventory(@NotNull Inventory inventory) {
+        return InventoryAccess.isPlayerInventory(inventory);
+    }

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -16,6 +16,9 @@

 package com.lishid.openinv.internal;

+/**
+ * An {@link ISpecialInventory} representing an ender chest.
+ */
 public interface ISpecialEnderChest extends ISpecialInventory {

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -21,38 +21,43 @@ import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
 import org.jetbrains.annotations.NotNull;

+/**
+ * Interface defining behavior for special inventories backed by other inventories' content listings.
+ */
 public interface ISpecialInventory {

    /**
-     * Gets the Inventory associated with this ISpecialInventory.
+     * Get the {@link Inventory} associated with this {@code ISpecialInventory}.
     *
-     * @return the Inventory
+     * @return the Bukkit inventory
     */
    @NotNull Inventory getBukkitInventory();

    /**
-     * Sets the Player associated with this ISpecialInventory online.
+     * Set the owning {@link Player} instance to a newly-joined user.
     *
-     * @param player the Player coming online
+     * @param player the user coming online
     */
    void setPlayerOnline(@NotNull Player player);

    /**
-     * Sets the Player associated with this ISpecialInventory offline.
+     * Mark the owner of the inventory offline.
     */
    void setPlayerOffline();

    /**
-     * Gets whether or not this ISpecialInventory is in use.
+     * Get whether the inventory is being viewed by any users.
     *
-     * @return true if the ISpecialInventory is in use
+     * @return true if the inventory is being viewed
     */
-    boolean isInUse();
+    default boolean isInUse() {
+        return !getBukkitInventory().getViewers().isEmpty();
+    }

    /**
-     * Gets the Player associated with this ISpecialInventory.
+     * Get the {@link Player} who owns the inventory.
     *
-     * @return the HumanEntity
+     * @return the {@link HumanEntity} who owns the inventory
     */
    @NotNull HumanEntity getPlayer();

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -16,6 +16,35 @@

 package com.lishid.openinv.internal;

+import java.util.List;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.Inventory;
+
+/**
+ * An {@link ISpecialInventory} representing a player inventory.
+ */
 public interface ISpecialPlayerInventory extends ISpecialInventory {

+    /*
+     * Player inventory usage varies from all other inventories - as the inventory is technically open at all times,
+     * if the player is online or has been online while the inventory is open, they are in the viewer list.
+     */
+    @Override
+    default boolean isInUse() {
+        Inventory inventory = getBukkitInventory();
+        List<HumanEntity> viewers = inventory.getViewers();
+
+        if (viewers.size() != 1) {
+            return !viewers.isEmpty();
+        }
+
+        HumanEntity viewer = viewers.get(0);
+
+        if (!viewer.getUniqueId().equals(getPlayer().getUniqueId())) {
+            return true;
+        }
+
+        return viewer.getOpenInventory().getTopInventory().equals(inventory);
+    }
+
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,14 +20,13 @@ import com.lishid.openinv.internal.IInventoryAccess;
 import com.lishid.openinv.internal.ISpecialEnderChest;
 import com.lishid.openinv.internal.ISpecialInventory;
 import com.lishid.openinv.internal.ISpecialPlayerInventory;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import org.bukkit.Bukkit;
 import org.bukkit.inventory.Inventory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

-public class InventoryAccess implements IInventoryAccess {
+public final class InventoryAccess implements IInventoryAccess {

    private static Class<?> craftInventory = null;
    private static Method getInventory = null;
@@ -36,16 +35,14 @@ public class InventoryAccess implements IInventoryAccess {
        String packageName = Bukkit.getServer().getClass().getPackage().getName();
        try {
            craftInventory = Class.forName(packageName + ".inventory.CraftInventory");
-        } catch (ClassNotFoundException ignored) {}
-        try {
            getInventory = craftInventory.getDeclaredMethod("getInventory");
-        } catch (NoSuchMethodException ignored) {}
+        } catch (ClassNotFoundException | NoSuchMethodException ignored) {}
    }

    /**
     * @deprecated use {@link #isUsable()}
     */
-    @Deprecated
+    @Deprecated(forRemoval = true)
    public static boolean isUseable() {
        return isUsable();
    }
@@ -54,25 +51,51 @@ public class InventoryAccess implements IInventoryAccess {
        return craftInventory != null && getInventory != null;
    }

+    /**
+     * Check if an {@link Inventory} is an {@link ISpecialPlayerInventory} implementation.
+     *
+     * @param inventory the Bukkit inventory
+     * @return true if backed by the correct implementation
+     */
    public static boolean isPlayerInventory(@NotNull Inventory inventory) {
        return getPlayerInventory(inventory) != null;
    }

+    /**
+     * Get the {@link ISpecialPlayerInventory} backing an {@link Inventory}. Returns {@code null} if the inventory is
+     * not backed by the correct class.
+     *
+     * @param inventory the Bukkit inventory
+     * @return the backing implementation if available
+     */
    public static @Nullable ISpecialPlayerInventory getPlayerInventory(@NotNull Inventory inventory) {
        return getSpecialInventory(ISpecialPlayerInventory.class, inventory);
    }

+    /**
+     * Check if an {@link Inventory} is an {@link ISpecialEnderChest} implementation.
+     *
+     * @param inventory the Bukkit inventory
+     * @return true if backed by the correct implementation
+     */
    public static boolean isEnderChest(@NotNull Inventory inventory) {
        return getEnderChest(inventory) != null;
    }

+    /**
+     * Get the {@link ISpecialEnderChest} backing an {@link Inventory}. Returns {@code null} if the inventory is
+     * not backed by the correct class.
+     *
+     * @param inventory the Bukkit inventory
+     * @return the backing implementation if available
+     */
    public static @Nullable ISpecialEnderChest getEnderChest(@NotNull Inventory inventory) {
        return getSpecialInventory(ISpecialEnderChest.class, inventory);
    }

    private static <T extends ISpecialInventory> @Nullable T getSpecialInventory(@NotNull Class<T> expected, @NotNull Inventory inventory) {
        Object inv;
-        if (craftInventory != null && getInventory != null && craftInventory.isAssignableFrom(inventory.getClass())) {
+        if (isUsable() && craftInventory.isAssignableFrom(inventory.getClass())) {
            try {
                inv = getInventory.invoke(inventory);
                if (expected.isInstance(inv)) {
@@ -81,7 +104,8 @@ public class InventoryAccess implements IInventoryAccess {
            } catch (ReflectiveOperationException ignored) {}
        }

-        inv = grabFieldOfTypeFromObject(expected, inventory);
+        // Use reflection to find the IInventory
+        inv = ReflectionHelper.grabObjectByType(inventory, expected);

        if (expected.isInstance(inv)) {
            return expected.cast(inv);
@@ -90,45 +114,10 @@ public class InventoryAccess implements IInventoryAccess {
        return null;
    }

-    private static <T> @Nullable T grabFieldOfTypeFromObject(final Class<T> type, final Object object) {
-        // Use reflection to find the IInventory
-        Class<?> clazz = object.getClass();
-        T result = null;
-        for (Field f : clazz.getDeclaredFields()) {
-            f.setAccessible(true);
-            if (type.isAssignableFrom(f.getDeclaringClass())) {
-                try {
-                    result = type.cast(f.get(object));
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
-        }
-        return result;
-    }
-
-    @Deprecated
-    @Override
-    public @Nullable ISpecialEnderChest getSpecialEnderChest(@NotNull Inventory inventory) {
-        return getEnderChest(inventory);
-    }
-
-    @Deprecated
-    @Override
-    public @Nullable ISpecialPlayerInventory getSpecialPlayerInventory(@NotNull Inventory inventory) {
-        return getPlayerInventory(inventory);
-    }
-
-    @Deprecated
-    @Override
-    public boolean isSpecialEnderChest(@NotNull Inventory inventory) {
-        return isEnderChest(inventory);
-    }
-
-    @Deprecated
-    @Override
-    public boolean isSpecialPlayerInventory(@NotNull Inventory inventory) {
-        return isPlayerInventory(inventory);
-    }
+    /**
+     * @deprecated Do not create a new instance to use static methods.
+     */
+    @Deprecated(forRemoval = true, since = "4.2.0")
+    public InventoryAccess() {}

 }
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2011-2021 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.util;
+
+import java.lang.reflect.Field;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A utility for making reflection easier.
+ */
+public final class ReflectionHelper {
+
+    private ReflectionHelper() {}
+
+    /**
+     * Grab an {@link Object} stored in a {@link Field} of another {@code Object}.
+     *
+     * <p>This casts the field to the correct class. Any issues will result in a {@code null} return value.
+     *
+     * @param fieldType the {@link Class} of {@code Object} stored in the {@code Field}
+     * @param holder the containing {@code Object}
+     * @param <T> the type of stored {@code Object}
+     * @return the first matching {@code Object} or {@code null} if none match
+     */
+    public static <T> @Nullable T grabObjectByType(final Object holder, final Class<T> fieldType) {
+        Field field = grabFieldByType(holder.getClass(), fieldType);
+
+        if (field != null) {
+            try {
+                return fieldType.cast(field.get(holder));
+            } catch (IllegalAccessException ignored) {
+                // Ignore issues obtaining field
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Grab a {@link Field} of an {@link Object}
+     *
+     * @param fieldType the {@link Class} of the object
+     * @param holderType the containing {@code Class}
+     * @return the first matching object or {@code null} if none match
+     */
+    public static @Nullable Field grabFieldByType(Class<?> holderType, Class<?> fieldType) {
+        for (Field field : holderType.getDeclaredFields()) {
+            field.setAccessible(true);
+            if (fieldType.isAssignableFrom(field.getType())) {
+                return field;
+            }
+        }
+
+        if (holderType.getSuperclass() != null) {
+            return grabFieldByType(fieldType, holderType.getSuperclass());
+        }
+
+        return null;
+    }
+
+}
@@ -1,58 +0,0 @@
-<!--
-  ~ Copyright (C) 2011-2021 lishid. All rights reserved.
-  ~
-  ~ This program is free software: you can redistribute it and/or modify
-  ~ it under the terms of the GNU General Public License as published by
-  ~ the Free Software Foundation, version 3.
-  ~
-  ~ 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 General Public License for more details.
-  ~
-  ~ You should have received a copy of the GNU General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <groupId>com.lishid</groupId>
-    <artifactId>openinvparent</artifactId>
-    <version>4.1.9-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>openinvassembly</artifactId>
-  <name>OpenInvAssembly</name>
-  <packaging>pom</packaging>
-
-  <build>
-    <directory>../target</directory>
-    <finalName>OpenInv</finalName>
-
-    <plugins>
-      <plugin>
-        <artifactId>maven-assembly-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>reactor-uberjar</id>
-            <phase>package</phase>
-            <goals>
-              <goal>single</goal>
-            </goals>
-            <configuration>
-              <appendAssemblyId>false</appendAssemblyId>
-              <descriptors>
-                <descriptor>src/assembly/reactor-uberjar.xml</descriptor>
-              </descriptors>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-
-  </build>
-
-</project>
@@ -1,54 +0,0 @@
-<!--
-  ~ Copyright (C) 2011-2021 lishid. All rights reserved.
-  ~
-  ~ This program is free software: you can redistribute it and/or modify
-  ~ it under the terms of the GNU General Public License as published by
-  ~ the Free Software Foundation, version 3.
-  ~
-  ~ 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 General Public License for more details.
-  ~
-  ~ You should have received a copy of the GNU General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.0 http://maven.apache.org/xsd/assembly-2.1.0.xsd">
-
-  <id>reactor-uberjar</id>
-
-  <formats>
-    <format>jar</format>
-  </formats>
-
-  <includeBaseDirectory>false</includeBaseDirectory>
-
-  <moduleSets>
-    <moduleSet>
-
-      <useAllReactorProjects>true</useAllReactorProjects>
-
-      <binaries>
-        <outputDirectory>/</outputDirectory>
-        <unpack>true</unpack>
-        <unpackOptions>
-          <excludes>
-            <!--
-              - Exclude existing meta - assembly will write its own manifest, and the rest is maven
-              - details that end users don't need. Ignoring it saves around 7KB after compression
-              - with a single internal module present.
-             -->
-            <exclude>META-INF/**</exclude>
-          </excludes>
-        </unpackOptions>
-        <!-- Exclude dependencies - shade plugin will handle their inclusion as necessary in individual jars. -->
-        <includeDependencies>false</includeDependencies>
-      </binaries>
-
-    </moduleSet>
-  </moduleSets>
-
-</assembly>
@@ -0,0 +1,102 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import io.papermc.paperweight.userdev.ReobfArtifactConfiguration
+import io.papermc.paperweight.tasks.RemapJar
+
+plugins {
+    java
+    `java-library`
+    id("com.gradleup.shadow") version "8.3.9"
+    id("io.papermc.paperweight.userdev") version "2.0.0-beta.18"
+    eclipse
+}
+
+group = "com.lishid"
+version = "4.4.4-SNAPSHOT"
+
+val apiVersion = "1.19"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+        vendor.set(JvmVendorSpec.GRAAL_VM)
+    }
+}
+
+paperweight.reobfArtifactConfiguration = ReobfArtifactConfiguration.REOBF_PRODUCTION
+
+repositories {
+    mavenCentral()
+    maven("https://repo.papermc.io/repository/maven-public/")
+    maven("https://repo.purpurmc.org/snapshots")
+}
+
+dependencies {
+    paperweight.paperDevBundle("1.19.4-R0.1-SNAPSHOT")
+    compileOnly("org.jetbrains:annotations:24.1.0")
+    compileOnly("org.purpurmc.purpur:purpur-api:1.19.4-R0.1-SNAPSHOT")
+}
+
+sourceSets {
+    main {
+        java.setSrcDirs(
+            listOf(
+                "api/src/main/java",
+                "plugin/src/main/java",
+                "internal/v1_19_R3/src/main/java",
+            ),
+        )
+        resources.setSrcDirs(listOf("plugin/src/main/resources"))
+    }
+}
+
+tasks.withType<JavaCompile>().configureEach {
+    options.encoding = "UTF-8"
+    options.release.set(17)
+    options.compilerArgs.add("-parameters")
+}
+
+tasks.withType<AbstractArchiveTask>().configureEach {
+    isPreserveFileTimestamps = false
+    isReproducibleFileOrder = true
+    archiveBaseName.set("OpenInv")
+}
+
+tasks.processResources {
+    val props = mapOf("version" to project.version, "apiVersion" to apiVersion)
+    inputs.properties(props)
+    filesMatching("plugin.yml") {
+        expand(props)
+    }
+    from("LICENSE.txt") {
+        into("/")
+    }
+}
+
+tasks.jar {
+    archiveClassifier.set("dev")
+}
+
+tasks.withType<ShadowJar>().configureEach {
+    archiveClassifier.set("dev-all")
+    minimize()
+}
+
+tasks.named("assemble") {
+    dependsOn(tasks.named("reobfJar"))
+}
+
+tasks.named("build") {
+    dependsOn(tasks.named("shadowJar"))
+}
+
+tasks.named<RemapJar>("reobfJar") {
+    outputJar.set(layout.buildDirectory.file("libs/OpenInv-${project.version}.jar"))
+}
+
+eclipse {
+    project {
+        name = rootProject.name
+    }
+}
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# 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.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   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
+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
+
+# 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\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+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  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH="\\\"\\\""
+
+
+# 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
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    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" && ! "$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
+
+# 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.
+
+# 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" )
+
+    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, 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" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# 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" "$@"
@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@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
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+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"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+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
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+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
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+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!
+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
+
+:omega
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright (C) 2011-2021 lishid. All rights reserved.
-  ~
-  ~ This program is free software: you can redistribute it and/or modify
-  ~ it under the terms of the GNU General Public License as published by
-  ~ the Free Software Foundation, version 3.
-  ~
-  ~ 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 General Public License for more details.
-  ~
-  ~ You should have received a copy of the GNU General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <artifactId>openinvparent</artifactId>
-    <groupId>com.lishid</groupId>
-    <relativePath>../../pom.xml</relativePath>
-    <version>4.1.9-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>openinvadapter1_16_R3</artifactId>
-  <name>OpenInvAdapter1_16_R3</name>
-
-  <dependencies>
-    <dependency>
-      <artifactId>spigot</artifactId>
-      <groupId>org.spigotmc</groupId>
-      <scope>provided</scope>
-      <version>1.16.5-R0.1-SNAPSHOT</version>
-    </dependency>
-    <dependency>
-      <artifactId>openinvapi</artifactId>
-      <groupId>com.lishid</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>openinvplugincore</artifactId>
-      <groupId>com.lishid</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>annotations</artifactId>
-      <groupId>org.jetbrains</groupId>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
-
-</project>
@@ -1,245 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_16_R3;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.internal.IAnySilentContainer;
-import java.lang.reflect.Field;
-import net.minecraft.server.v1_16_R3.Block;
-import net.minecraft.server.v1_16_R3.BlockBarrel;
-import net.minecraft.server.v1_16_R3.BlockChest;
-import net.minecraft.server.v1_16_R3.BlockChestTrapped;
-import net.minecraft.server.v1_16_R3.BlockPosition;
-import net.minecraft.server.v1_16_R3.BlockPropertyChestType;
-import net.minecraft.server.v1_16_R3.BlockShulkerBox;
-import net.minecraft.server.v1_16_R3.ChatMessage;
-import net.minecraft.server.v1_16_R3.Container;
-import net.minecraft.server.v1_16_R3.ContainerChest;
-import net.minecraft.server.v1_16_R3.Containers;
-import net.minecraft.server.v1_16_R3.EntityHuman;
-import net.minecraft.server.v1_16_R3.EntityPlayer;
-import net.minecraft.server.v1_16_R3.EnumGamemode;
-import net.minecraft.server.v1_16_R3.IBlockData;
-import net.minecraft.server.v1_16_R3.IChatBaseComponent;
-import net.minecraft.server.v1_16_R3.ITileInventory;
-import net.minecraft.server.v1_16_R3.InventoryEnderChest;
-import net.minecraft.server.v1_16_R3.InventoryLargeChest;
-import net.minecraft.server.v1_16_R3.PlayerInteractManager;
-import net.minecraft.server.v1_16_R3.PlayerInventory;
-import net.minecraft.server.v1_16_R3.TileEntity;
-import net.minecraft.server.v1_16_R3.TileEntityChest;
-import net.minecraft.server.v1_16_R3.TileEntityEnderChest;
-import net.minecraft.server.v1_16_R3.TileEntityLootable;
-import net.minecraft.server.v1_16_R3.TileInventory;
-import net.minecraft.server.v1_16_R3.World;
-import org.bukkit.Material;
-import org.bukkit.Statistic;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryView;
-import org.jetbrains.annotations.NotNull;
-
-public class AnySilentContainer implements IAnySilentContainer {
-
-    private Field playerInteractManagerGamemode;
-
-    public AnySilentContainer() {
-        try {
-            this.playerInteractManagerGamemode = PlayerInteractManager.class.getDeclaredField("gamemode");
-            this.playerInteractManagerGamemode.setAccessible(true);
-        } catch (NoSuchFieldException | SecurityException e) {
-            System.err.println("[OpenInv] Unable to directly write player gamemode! SilentChest will fail.");
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    public boolean activateContainer(@NotNull final Player bukkitPlayer, final boolean silentchest,
-                                     @NotNull final org.bukkit.block.Block bukkitBlock) {
-
-        // Silent ender chest is API-only
-        if (silentchest && bukkitBlock.getType() == Material.ENDER_CHEST) {
-            bukkitPlayer.openInventory(bukkitPlayer.getEnderChest());
-            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
-            return true;
-        }
-
-        EntityPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
-
-        final World world = player.world;
-        final BlockPosition blockPosition = new BlockPosition(bukkitBlock.getX(), bukkitBlock.getY(), bukkitBlock.getZ());
-        final TileEntity tile = world.getTileEntity(blockPosition);
-
-        if (tile == null) {
-            return false;
-        }
-
-        if (tile instanceof TileEntityEnderChest) {
-            // Anychest ender chest. See net.minecraft.server.BlockEnderChest
-            InventoryEnderChest enderChest = player.getEnderChest();
-            enderChest.a((TileEntityEnderChest) tile);
-            player.openContainer(new TileInventory((containerCounter, playerInventory, ignored) -> {
-                Containers<?> containers = PlayerDataManager.getContainers(enderChest.getSize());
-                int rows = enderChest.getSize() / 9;
-                return new ContainerChest(containers, containerCounter, playerInventory, enderChest, rows);
-            }, new ChatMessage("container.enderchest")));
-            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
-            return true;
-        }
-
-        if (!(tile instanceof ITileInventory)) {
-            return false;
-        }
-
-        ITileInventory tileInventory = (ITileInventory) tile;
-        IBlockData blockData = world.getType(blockPosition);
-        Block block = blockData.getBlock();
-
-        if (block instanceof BlockChest) {
-
-            BlockPropertyChestType chestType = blockData.get(BlockChest.c);
-
-            if (chestType != BlockPropertyChestType.SINGLE) {
-
-                BlockPosition adjacentBlockPosition = blockPosition.shift(BlockChest.h(blockData));
-                IBlockData adjacentBlockData = world.getType(adjacentBlockPosition);
-
-                if (adjacentBlockData.getBlock() == block) {
-
-                    BlockPropertyChestType adjacentChestType = adjacentBlockData.get(BlockChest.c);
-
-                    if (adjacentChestType != BlockPropertyChestType.SINGLE && chestType != adjacentChestType
-                            && adjacentBlockData.get(BlockChest.FACING) == blockData.get(BlockChest.FACING)) {
-
-                        TileEntity adjacentTile = world.getTileEntity(adjacentBlockPosition);
-
-                        if (adjacentTile instanceof TileEntityChest && tileInventory instanceof  TileEntityChest) {
-                            TileEntityChest rightChest = chestType == BlockPropertyChestType.RIGHT ? ((TileEntityChest) tileInventory) : (TileEntityChest) adjacentTile;
-                            TileEntityChest leftChest = chestType == BlockPropertyChestType.RIGHT ? (TileEntityChest) adjacentTile : ((TileEntityChest) tileInventory);
-
-                            if (silentchest && (rightChest.lootTable != null || leftChest.lootTable != null)) {
-                                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
-                                return false;
-                            }
-
-                            tileInventory = new ITileInventory() {
-                                public Container createMenu(int containerCounter, PlayerInventory playerInventory, EntityHuman entityHuman) {
-                                    leftChest.d(playerInventory.player);
-                                    rightChest.d(playerInventory.player);
-                                    return ContainerChest.b(containerCounter, playerInventory, new InventoryLargeChest(rightChest, leftChest));
-                                }
-
-                                public IChatBaseComponent getScoreboardDisplayName() {
-                                    if (leftChest.hasCustomName()) {
-                                        return leftChest.getScoreboardDisplayName();
-                                    }
-                                    if (rightChest.hasCustomName()) {
-                                        return rightChest.getScoreboardDisplayName();
-                                    }
-                                    return new ChatMessage("container.chestDouble");
-                                }
-                            };
-                        }
-                    }
-                }
-            }
-
-            if (block instanceof BlockChestTrapped) {
-                bukkitPlayer.incrementStatistic(Statistic.TRAPPED_CHEST_TRIGGERED);
-            } else {
-                bukkitPlayer.incrementStatistic(Statistic.CHEST_OPENED);
-            }
-        }
-
-        if (block instanceof BlockShulkerBox) {
-            bukkitPlayer.incrementStatistic(Statistic.SHULKER_BOX_OPENED);
-        }
-
-        if (block instanceof BlockBarrel) {
-            bukkitPlayer.incrementStatistic(Statistic.OPEN_BARREL);
-        }
-
-        // AnyChest only - SilentChest not active, container unsupported, or unnecessary.
-        if (!silentchest || player.playerInteractManager.getGameMode() == EnumGamemode.SPECTATOR) {
-            player.openContainer(tileInventory);
-            return true;
-        }
-
-        // SilentChest requires access to setting players' gamemode directly.
-        if (this.playerInteractManagerGamemode == null) {
-            return false;
-        }
-
-        if (tile instanceof TileEntityLootable) {
-            TileEntityLootable lootable = (TileEntityLootable) tile;
-            if (lootable.lootTable != null) {
-                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
-                return false;
-            }
-        }
-
-        EnumGamemode gamemode = player.playerInteractManager.getGameMode();
-        this.forceGameMode(player, EnumGamemode.SPECTATOR);
-        player.openContainer(tileInventory);
-        this.forceGameMode(player, gamemode);
-        return true;
-    }
-
-    @Override
-    public void deactivateContainer(@NotNull final Player bukkitPlayer) {
-        if (this.playerInteractManagerGamemode == null) {
-            return;
-        }
-
-        InventoryView view = bukkitPlayer.getOpenInventory();
-        switch (view.getType()) {
-            case CHEST:
-            case ENDER_CHEST:
-            case SHULKER_BOX:
-            case BARREL:
-                break;
-            default:
-                return;
-        }
-
-        EntityPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
-
-        EnumGamemode gamemode = player.playerInteractManager.getGameMode();
-        this.forceGameMode(player, EnumGamemode.SPECTATOR);
-        player.activeContainer.b(player);
-        player.activeContainer.a(player, false);
-        player.activeContainer.transferTo(player.defaultContainer, player.getBukkitEntity());
-        player.activeContainer = player.defaultContainer;
-        this.forceGameMode(player, gamemode);
-    }
-
-    private void forceGameMode(final EntityPlayer player, final EnumGamemode gameMode) {
-        if (this.playerInteractManagerGamemode == null) {
-            // No need to warn repeatedly, error on startup and lack of function should be enough.
-            return;
-        }
-        try {
-            if (!this.playerInteractManagerGamemode.isAccessible()) {
-                // Just in case, ensure accessible.
-                this.playerInteractManagerGamemode.setAccessible(true);
-            }
-            this.playerInteractManagerGamemode.set(player.playerInteractManager, gameMode);
-        } catch (IllegalArgumentException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-}
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_16_R3;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import net.minecraft.server.v1_16_R3.EntityPlayer;
-import net.minecraft.server.v1_16_R3.NBTCompressedStreamTools;
-import net.minecraft.server.v1_16_R3.NBTTagCompound;
-import net.minecraft.server.v1_16_R3.WorldNBTStorage;
-import org.apache.logging.log4j.LogManager;
-import org.bukkit.craftbukkit.v1_16_R3.CraftServer;
-import org.bukkit.craftbukkit.v1_16_R3.entity.CraftPlayer;
-
-public class OpenPlayer extends CraftPlayer {
-
-    public OpenPlayer(CraftServer server, EntityPlayer entity) {
-        super(server, entity);
-    }
-
-    @Override
-    public void loadData() {
-        // See CraftPlayer#loadData
-        NBTTagCompound loaded = this.server.getHandle().playerFileData.load(this.getHandle());
-        if (loaded != null) {
-            readExtraData(loaded);
-        }
-    }
-
-    @Override
-    public void saveData() {
-        EntityPlayer player = this.getHandle();
-        // See net.minecraft.server.WorldNBTStorage#save(EntityPlayer)
-        try {
-            WorldNBTStorage worldNBTStorage = player.server.getPlayerList().playerFileData;
-
-            NBTTagCompound playerData = player.save(new NBTTagCompound());
-            setExtraData(playerData);
-
-            if (!isOnline()) {
-                // Special case: save old vehicle data
-                NBTTagCompound oldData = worldNBTStorage.load(player);
-
-                if (oldData != null && oldData.hasKeyOfType("RootVehicle", 10)) {
-                    // See net.minecraft.server.PlayerList#a(NetworkManager, EntityPlayer) and net.minecraft.server.EntityPlayer#b(NBTTagCompound)
-                    playerData.set("RootVehicle", oldData.getCompound("RootVehicle"));
-                }
-            }
-
-            File file = new File(worldNBTStorage.getPlayerDir(), player.getUniqueIDString() + ".dat.tmp");
-            File file1 = new File(worldNBTStorage.getPlayerDir(), player.getUniqueIDString() + ".dat");
-
-            NBTCompressedStreamTools.a(playerData, new FileOutputStream(file));
-
-            if (file1.exists() && !file1.delete() || !file.renameTo(file1)) {
-                LogManager.getLogger().warn("Failed to save player data for {}", player.getDisplayName().getString());
-            }
-
-        } catch (Exception e) {
-            LogManager.getLogger().warn("Failed to save player data for {}", player.getDisplayName().getString());
-        }
-    }
-
-}
@@ -1,235 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_16_R3;
-
-import com.lishid.openinv.internal.IPlayerDataManager;
-import com.lishid.openinv.internal.ISpecialInventory;
-import com.lishid.openinv.internal.OpenInventoryView;
-import com.mojang.authlib.GameProfile;
-import java.lang.reflect.Field;
-import net.minecraft.server.v1_16_R3.ChatComponentText;
-import net.minecraft.server.v1_16_R3.Container;
-import net.minecraft.server.v1_16_R3.Containers;
-import net.minecraft.server.v1_16_R3.Entity;
-import net.minecraft.server.v1_16_R3.EntityPlayer;
-import net.minecraft.server.v1_16_R3.MinecraftServer;
-import net.minecraft.server.v1_16_R3.PacketPlayOutOpenWindow;
-import net.minecraft.server.v1_16_R3.PlayerInteractManager;
-import net.minecraft.server.v1_16_R3.World;
-import net.minecraft.server.v1_16_R3.WorldServer;
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.Server;
-import org.bukkit.craftbukkit.v1_16_R3.CraftServer;
-import org.bukkit.craftbukkit.v1_16_R3.entity.CraftPlayer;
-import org.bukkit.craftbukkit.v1_16_R3.event.CraftEventFactory;
-import org.bukkit.craftbukkit.v1_16_R3.inventory.CraftContainer;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryView;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class PlayerDataManager implements IPlayerDataManager {
-
-    private @Nullable Field bukkitEntity;
-
-    public PlayerDataManager() {
-        try {
-            bukkitEntity = Entity.class.getDeclaredField("bukkitEntity");
-        } catch (NoSuchFieldException e) {
-            System.out.println("Unable to obtain field to inject custom save process - players' mounts may be deleted when loaded.");
-            e.printStackTrace();
-            bukkitEntity = null;
-        }
-    }
-
-    public static @NotNull EntityPlayer getHandle(final Player player) {
-        if (player instanceof CraftPlayer) {
-            return ((CraftPlayer) player).getHandle();
-        }
-
-        Server server = player.getServer();
-        EntityPlayer nmsPlayer = null;
-
-        if (server instanceof CraftServer) {
-            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getName());
-        }
-
-        if (nmsPlayer == null) {
-            // Could use reflection to examine fields, but it's honestly not worth the bother.
-            throw new RuntimeException("Unable to fetch EntityPlayer from provided Player implementation");
-        }
-
-        return nmsPlayer;
-    }
-
-    @Override
-    public @Nullable Player loadPlayer(@NotNull final OfflinePlayer offline) {
-        // Ensure player has data
-        if (!offline.hasPlayedBefore()) {
-            return null;
-        }
-
-        // Create a profile and entity to load the player data
-        // See net.minecraft.server.PlayerList#attemptLogin
-        GameProfile profile = new GameProfile(offline.getUniqueId(),
-                offline.getName() != null ? offline.getName() : offline.getUniqueId().toString());
-        MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
-        WorldServer worldServer = server.getWorldServer(World.OVERWORLD);
-
-        if (worldServer == null) {
-            return null;
-        }
-
-        EntityPlayer entity = new EntityPlayer(server, worldServer, profile, new PlayerInteractManager(worldServer));
-
-        try {
-            injectPlayer(entity);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-
-        // Get the bukkit entity
-        Player target = entity.getBukkitEntity();
-        if (target != null) {
-            // Load data
-            target.loadData();
-        }
-        // Return the entity
-        return target;
-    }
-
-    void injectPlayer(EntityPlayer player) throws IllegalAccessException {
-        if (bukkitEntity == null) {
-            return;
-        }
-
-        bukkitEntity.setAccessible(true);
-
-        bukkitEntity.set(player, new OpenPlayer(player.server.server, player));
-    }
-
-    @NotNull
-    @Override
-    public Player inject(@NotNull Player player) {
-        try {
-            EntityPlayer nmsPlayer = getHandle(player);
-            injectPlayer(nmsPlayer);
-            return nmsPlayer.getBukkitEntity();
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-            return player;
-        }
-    }
-
-    @Nullable
-    @Override
-    public InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {
-
-        EntityPlayer nmsPlayer = getHandle(player);
-
-        if (nmsPlayer.playerConnection == null) {
-            return null;
-        }
-
-        InventoryView view = getView(player, inventory);
-
-        if (view == null) {
-            return player.openInventory(inventory.getBukkitInventory());
-        }
-
-        Container container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
-            @Override
-            public Containers<?> getType() {
-                return getContainers(inventory.getBukkitInventory().getSize());
-            }
-        };
-
-        container.setTitle(new ChatComponentText(view.getTitle()));
-        container = CraftEventFactory.callInventoryOpenEvent(nmsPlayer, container);
-
-        if (container == null) {
-            return null;
-        }
-
-        nmsPlayer.playerConnection.sendPacket(new PacketPlayOutOpenWindow(container.windowId, container.getType(),
-                new ChatComponentText(container.getBukkitView().getTitle())));
-        nmsPlayer.activeContainer = container;
-        container.addSlotListener(nmsPlayer);
-
-        return container.getBukkitView();
-
-    }
-
-    private @Nullable InventoryView getView(Player player, ISpecialInventory inventory) {
-        if (inventory instanceof SpecialEnderChest) {
-            return new OpenInventoryView(player, inventory, "container.enderchest", "'s Ender Chest");
-        } else if (inventory instanceof SpecialPlayerInventory) {
-            return new OpenInventoryView(player, inventory, "container.player", "'s Inventory");
-        } else {
-            return null;
-        }
-    }
-
-    static @NotNull Containers<?> getContainers(int inventorySize) {
-        switch (inventorySize) {
-            case 9:
-                return Containers.GENERIC_9X1;
-            case 18:
-                return Containers.GENERIC_9X2;
-            case 36:
-                return Containers.GENERIC_9X4;
-            case 41: // PLAYER
-            case 45:
-                return Containers.GENERIC_9X5;
-            case 54:
-                return Containers.GENERIC_9X6;
-            case 27:
-            default:
-                return Containers.GENERIC_9X3;
-        }
-    }
-
-    @Override
-    public int convertToPlayerSlot(InventoryView view, int rawSlot) {
-        int topSize = view.getTopInventory().getSize();
-        if (topSize <= rawSlot) {
-            // Slot is not inside special inventory, use Bukkit logic.
-            return view.convertSlot(rawSlot);
-        }
-
-        // Main inventory, slots 0-26 -> 9-35
-        if (rawSlot < 27) {
-            return rawSlot + 9;
-        }
-        // Hotbar, slots 27-35 -> 0-8
-        if (rawSlot < 36) {
-            return rawSlot - 27;
-        }
-        // Armor, slots 36-39 -> 39-36
-        if (rawSlot < 40) {
-            return 36 + (39 - rawSlot);
-        }
-        // Off hand
-        if (rawSlot == 40) {
-            return 40;
-        }
-        // Drop slots, "out of inventory"
-        return -1;
-    }
-
-}
@@ -1,261 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_16_R3;
-
-import com.lishid.openinv.internal.ISpecialEnderChest;
-import java.util.List;
-import net.minecraft.server.v1_16_R3.AutoRecipeStackManager;
-import net.minecraft.server.v1_16_R3.ContainerUtil;
-import net.minecraft.server.v1_16_R3.EntityHuman;
-import net.minecraft.server.v1_16_R3.EntityPlayer;
-import net.minecraft.server.v1_16_R3.IInventoryListener;
-import net.minecraft.server.v1_16_R3.InventoryEnderChest;
-import net.minecraft.server.v1_16_R3.ItemStack;
-import net.minecraft.server.v1_16_R3.NonNullList;
-import org.bukkit.Location;
-import org.bukkit.craftbukkit.v1_16_R3.entity.CraftHumanEntity;
-import org.bukkit.craftbukkit.v1_16_R3.inventory.CraftInventory;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryHolder;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class SpecialEnderChest extends InventoryEnderChest implements ISpecialEnderChest {
-
-    private final CraftInventory inventory;
-    private EntityPlayer owner;
-    private NonNullList<ItemStack> items;
-    private boolean playerOnline;
-
-    public SpecialEnderChest(final Player player, final Boolean online) {
-        super(PlayerDataManager.getHandle(player));
-        this.inventory = new CraftInventory(this);
-        this.owner = PlayerDataManager.getHandle(player);
-        this.playerOnline = online;
-        this.items = this.owner.getEnderChest().items;
-    }
-
-    @Override
-    public @NotNull CraftInventory getBukkitInventory() {
-        return inventory;
-    }
-
-    @Override
-    public boolean isInUse() {
-        return !this.getViewers().isEmpty();
-    }
-
-    @Override
-    public void setPlayerOffline() {
-        this.playerOnline = false;
-    }
-
-    @Override
-    public void setPlayerOnline(@NotNull final Player player) {
-        if (!this.playerOnline) {
-            try {
-                this.owner = PlayerDataManager.getHandle(player);
-                InventoryEnderChest enderChest = owner.getEnderChest();
-                for (int i = 0; i < enderChest.getSize(); ++i) {
-                    enderChest.setItem(i, this.items.get(i));
-                }
-                this.items = enderChest.items;
-            } catch (Exception ignored) {}
-            this.playerOnline = true;
-        }
-    }
-
-    @Override
-    public @NotNull Player getPlayer() {
-        return owner.getBukkitEntity();
-    }
-
-    @Override
-    public void update() {
-        this.owner.getEnderChest().update();
-    }
-
-    @Override
-    public List<ItemStack> getContents() {
-        return this.items;
-    }
-
-    @Override
-    public void onOpen(CraftHumanEntity who) {
-        this.owner.getEnderChest().onOpen(who);
-    }
-
-    @Override
-    public void onClose(CraftHumanEntity who) {
-        this.owner.getEnderChest().onClose(who);
-    }
-
-    @Override
-    public List<HumanEntity> getViewers() {
-        return this.owner.getEnderChest().getViewers();
-    }
-
-    @Override
-    public void setMaxStackSize(int i) {
-        this.owner.getEnderChest().setMaxStackSize(i);
-    }
-
-    @Override
-    public InventoryHolder getOwner() {
-        return this.owner.getEnderChest().getOwner();
-    }
-
-    @Override
-    public @Nullable Location getLocation() {
-        return null;
-    }
-
-    @Override
-    public void a(IInventoryListener iinventorylistener) {
-        this.owner.getEnderChest().a(iinventorylistener);
-    }
-
-    @Override
-    public void b(IInventoryListener iinventorylistener) {
-        this.owner.getEnderChest().b(iinventorylistener);
-    }
-
-    @Override
-    public ItemStack getItem(int i) {
-        return i >= 0 && i < this.items.size() ? this.items.get(i) : ItemStack.b;
-    }
-
-    @Override
-    public ItemStack splitStack(int i, int j) {
-        ItemStack itemstack = ContainerUtil.a(this.items, i, j);
-        if (!itemstack.isEmpty()) {
-            this.update();
-        }
-
-        return itemstack;
-    }
-
-    @Override
-    public ItemStack a(ItemStack itemstack) {
-        ItemStack itemstack1 = itemstack.cloneItemStack();
-
-        for (int i = 0; i < this.getSize(); ++i) {
-            ItemStack itemstack2 = this.getItem(i);
-            if (itemstack2.isEmpty()) {
-                this.setItem(i, itemstack1);
-                this.update();
-                return ItemStack.b;
-            }
-
-            if (ItemStack.c(itemstack2, itemstack1)) {
-                int j = Math.min(this.getMaxStackSize(), itemstack2.getMaxStackSize());
-                int k = Math.min(itemstack1.getCount(), j - itemstack2.getCount());
-                if (k > 0) {
-                    itemstack2.add(k);
-                    itemstack1.subtract(k);
-                    if (itemstack1.isEmpty()) {
-                        this.update();
-                        return ItemStack.b;
-                    }
-                }
-            }
-        }
-
-        if (itemstack1.getCount() != itemstack.getCount()) {
-            this.update();
-        }
-
-        return itemstack1;
-    }
-
-    @Override
-    public ItemStack splitWithoutUpdate(int i) {
-        ItemStack itemstack = this.items.get(i);
-        if (itemstack.isEmpty()) {
-            return ItemStack.b;
-        } else {
-            this.items.set(i, ItemStack.b);
-            return itemstack;
-        }
-    }
-
-    @Override
-    public void setItem(int i, ItemStack itemstack) {
-        this.items.set(i, itemstack);
-        if (!itemstack.isEmpty() && itemstack.getCount() > this.getMaxStackSize()) {
-            itemstack.setCount(this.getMaxStackSize());
-        }
-
-        this.update();
-    }
-
-    @Override
-    public int getSize() {
-        return this.owner.getEnderChest().getSize();
-    }
-
-    @Override
-    public boolean isEmpty() {
-
-        for (ItemStack itemstack : this.items) {
-            if (!itemstack.isEmpty()) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    @Override
-    public int getMaxStackSize() {
-        return 64;
-    }
-
-    @Override
-    public boolean a(EntityHuman entityhuman) {
-        return true;
-    }
-
-    @Override
-    public void startOpen(EntityHuman entityhuman) {
-    }
-
-    @Override
-    public void closeContainer(EntityHuman entityhuman) {
-    }
-
-    @Override
-    public boolean b(int i, ItemStack itemstack) {
-        return true;
-    }
-
-    @Override
-    public void clear() {
-        this.items.clear();
-    }
-
-    @Override
-    public void a(AutoRecipeStackManager autorecipestackmanager) {
-
-        for (ItemStack itemstack : this.items) {
-            autorecipestackmanager.b(itemstack);
-        }
-
-    }
-
-}
@@ -1,738 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_16_R3;
-
-import com.google.common.collect.ImmutableList;
-import com.lishid.openinv.internal.ISpecialPlayerInventory;
-import java.util.Iterator;
-import java.util.List;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import net.minecraft.server.v1_16_R3.AutoRecipeStackManager;
-import net.minecraft.server.v1_16_R3.ChatMessage;
-import net.minecraft.server.v1_16_R3.ContainerUtil;
-import net.minecraft.server.v1_16_R3.CrashReport;
-import net.minecraft.server.v1_16_R3.CrashReportSystemDetails;
-import net.minecraft.server.v1_16_R3.DamageSource;
-import net.minecraft.server.v1_16_R3.EntityHuman;
-import net.minecraft.server.v1_16_R3.EntityPlayer;
-import net.minecraft.server.v1_16_R3.EnumItemSlot;
-import net.minecraft.server.v1_16_R3.IBlockData;
-import net.minecraft.server.v1_16_R3.IChatBaseComponent;
-import net.minecraft.server.v1_16_R3.IInventory;
-import net.minecraft.server.v1_16_R3.Item;
-import net.minecraft.server.v1_16_R3.ItemArmor;
-import net.minecraft.server.v1_16_R3.ItemStack;
-import net.minecraft.server.v1_16_R3.NBTTagCompound;
-import net.minecraft.server.v1_16_R3.NBTTagList;
-import net.minecraft.server.v1_16_R3.NonNullList;
-import net.minecraft.server.v1_16_R3.PacketPlayOutSetSlot;
-import net.minecraft.server.v1_16_R3.PlayerInventory;
-import net.minecraft.server.v1_16_R3.ReportedException;
-import net.minecraft.server.v1_16_R3.World;
-import org.bukkit.Location;
-import org.bukkit.craftbukkit.v1_16_R3.entity.CraftHumanEntity;
-import org.bukkit.craftbukkit.v1_16_R3.inventory.CraftInventory;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryHolder;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class SpecialPlayerInventory extends PlayerInventory implements ISpecialPlayerInventory {
-
-    private final CraftInventory inventory;
-    private boolean playerOnline;
-    private EntityHuman player;
-    private NonNullList<ItemStack> items, armor, extraSlots;
-    private List<NonNullList<ItemStack>> f;
-
-    public SpecialPlayerInventory(final Player bukkitPlayer, final Boolean online) {
-        super(PlayerDataManager.getHandle(bukkitPlayer));
-        this.inventory = new CraftInventory(this);
-        this.playerOnline = online;
-        this.player = super.player;
-        this.items = this.player.inventory.items;
-        this.armor = this.player.inventory.armor;
-        this.extraSlots = this.player.inventory.extraSlots;
-        this.f = ImmutableList.of(this.items, this.armor, this.extraSlots);
-    }
-
-    @Override
-    public void setPlayerOnline(@NotNull final Player player) {
-        if (!this.playerOnline) {
-            EntityPlayer entityPlayer = PlayerDataManager.getHandle(player);
-            entityPlayer.inventory.transaction.addAll(this.transaction);
-            this.player = entityPlayer;
-            for (int i = 0; i < getSize(); ++i) {
-                this.player.inventory.setItem(i, getRawItem(i));
-            }
-            this.player.inventory.itemInHandIndex = this.itemInHandIndex;
-            this.items = this.player.inventory.items;
-            this.armor = this.player.inventory.armor;
-            this.extraSlots = this.player.inventory.extraSlots;
-            this.f = ImmutableList.of(this.items, this.armor, this.extraSlots);
-            this.playerOnline = true;
-        }
-    }
-
-    @Override
-    public boolean a(final EntityHuman entityhuman) {
-        return true;
-    }
-
-    @Override
-    public @NotNull CraftInventory getBukkitInventory() {
-        return this.inventory;
-    }
-
-    @Override
-    public ItemStack getItem(int i) {
-        List<ItemStack> list = this.items;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.armor;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.extraSlots;
-        } else if (list == this.armor) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            return ItemStack.b;
-        }
-
-        return list.get(i);
-    }
-
-    private ItemStack getRawItem(int i) {
-        NonNullList<ItemStack> list = null;
-        for (NonNullList<ItemStack> next : this.f) {
-            if (i < next.size()) {
-                list = next;
-                break;
-            }
-            i -= next.size();
-        }
-
-        return list == null ? ItemStack.b : list.get(i);
-    }
-
-    @Override
-    public IChatBaseComponent getDisplayName() {
-        return new ChatMessage(this.player.getName());
-    }
-
-    @Override
-    public boolean hasCustomName() {
-        return false;
-    }
-
-    private int getReversedArmorSlotNum(final int i) {
-        if (i == 0) {
-            return 3;
-        }
-        if (i == 1) {
-            return 2;
-        }
-        if (i == 2) {
-            return 1;
-        }
-        if (i == 3) {
-            return 0;
-        }
-        return i;
-    }
-
-    private int getReversedItemSlotNum(final int i) {
-        if (i >= 27) {
-            return i - 27;
-        }
-        return i + 9;
-    }
-
-    @Override
-    public int getSize() {
-        return 45;
-    }
-
-    @Override
-    public boolean isInUse() {
-        return !this.getViewers().isEmpty();
-    }
-
-    @Override
-    public void setItem(int i, final ItemStack itemstack) {
-        List<ItemStack> list = this.items;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.armor;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.extraSlots;
-        } else if (list == this.armor) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            this.player.drop(itemstack, true);
-            return;
-        }
-
-        list.set(i, itemstack);
-    }
-
-    @Override
-    public void setPlayerOffline() {
-        this.playerOnline = false;
-    }
-
-    @Override
-    public @NotNull HumanEntity getPlayer() {
-        return this.player.getBukkitEntity();
-    }
-
-    @Override
-    public ItemStack splitStack(int i, final int j) {
-        List<ItemStack> list = this.items;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.armor;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.extraSlots;
-        } else if (list == this.armor) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            return ItemStack.b;
-        }
-
-        return list.get(i).isEmpty() ? ItemStack.b : ContainerUtil.a(list, i, j);
-    }
-
-    @Override
-    public ItemStack splitWithoutUpdate(int i) {
-        List<ItemStack> list = this.items;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.armor;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.extraSlots;
-        } else if (list == this.armor) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            return ItemStack.b;
-        }
-
-        if (!list.get(i).isEmpty()) {
-            ItemStack itemstack = list.get(i);
-
-            list.set(i, ItemStack.b);
-            return itemstack;
-        }
-
-        return ItemStack.b;
-    }
-
-    @Override
-    public List<ItemStack> getContents() {
-        return this.f.stream().flatMap(List::stream).collect(Collectors.toList());
-    }
-
-    @Override
-    public List<ItemStack> getArmorContents() {
-        return this.armor;
-    }
-
-    @Override
-    public void onOpen(CraftHumanEntity who) {
-        this.transaction.add(who);
-    }
-
-    @Override
-    public void onClose(CraftHumanEntity who) {
-        this.transaction.remove(who);
-    }
-
-    @Override
-    public List<HumanEntity> getViewers() {
-        return this.transaction;
-    }
-
-    @Override
-    public InventoryHolder getOwner() {
-        return this.player.getBukkitEntity();
-    }
-
-    @Override
-    public Location getLocation() {
-        return this.player.getBukkitEntity().getLocation();
-    }
-
-    @Override
-    public ItemStack getItemInHand() {
-        return d(this.itemInHandIndex) ? this.items.get(this.itemInHandIndex) : ItemStack.b;
-    }
-
-    private boolean isSimilarAndNotFull(ItemStack itemstack, ItemStack itemstack1) {
-        return !itemstack.isEmpty() && this.b(itemstack, itemstack1) && itemstack.isStackable() && itemstack.getCount() < itemstack.getMaxStackSize() && itemstack.getCount() < this.getMaxStackSize();
-    }
-
-    private boolean b(ItemStack itemstack, ItemStack itemstack1) {
-        return itemstack.getItem() == itemstack1.getItem() && ItemStack.equals(itemstack, itemstack1);
-    }
-
-    @Override
-    public int canHold(ItemStack itemstack) {
-        int remains = itemstack.getCount();
-
-        for (int i = 0; i < this.items.size(); ++i) {
-            ItemStack itemstack1 = this.getItem(i);
-            if (itemstack1.isEmpty()) {
-                return itemstack.getCount();
-            }
-
-            if (!this.isSimilarAndNotFull(itemstack, itemstack1)) {
-                remains -= Math.min(itemstack1.getMaxStackSize(), this.getMaxStackSize()) - itemstack1.getCount();
-            }
-
-            if (remains <= 0) {
-                return itemstack.getCount();
-            }
-        }
-
-        ItemStack offhandItemStack = this.getItem(this.items.size() + this.armor.size());
-        if (this.isSimilarAndNotFull(offhandItemStack, itemstack)) {
-            remains -= Math.min(offhandItemStack.getMaxStackSize(), this.getMaxStackSize()) - offhandItemStack.getCount();
-        }
-
-        return itemstack.getCount() - remains;
-    }
-
-    @Override
-    public int getFirstEmptySlotIndex() {
-        for (int i = 0; i < this.items.size(); ++i) {
-            if (this.items.get(i).isEmpty()) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    @Override
-    public void c(int i) {
-        this.itemInHandIndex = this.i();
-        ItemStack itemstack = this.items.get(this.itemInHandIndex);
-        this.items.set(this.itemInHandIndex, this.items.get(i));
-        this.items.set(i, itemstack);
-    }
-
-    @Override
-    public int c(ItemStack itemstack) {
-        for (int i = 0; i < this.items.size(); ++i) {
-            ItemStack itemstack1 = this.items.get(i);
-            if (!this.items.get(i).isEmpty() && this.b(itemstack, this.items.get(i)) && !this.items.get(i).f() && !itemstack1.hasEnchantments() && !itemstack1.hasName()) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    @Override
-    public int i() {
-        int i;
-        int j;
-        for (j = 0; j < 9; ++j) {
-            i = (this.itemInHandIndex + j) % 9;
-            if (this.items.get(i).isEmpty()) {
-                return i;
-            }
-        }
-
-        for (j = 0; j < 9; ++j) {
-            i = (this.itemInHandIndex + j) % 9;
-            if (!this.items.get(i).hasEnchantments()) {
-                return i;
-            }
-        }
-
-        return this.itemInHandIndex;
-    }
-
-    @Override
-    public int a(Predicate<ItemStack> predicate, int i, IInventory iinventory) {
-        byte b0 = 0;
-        boolean flag = i == 0;
-        int j = b0 + ContainerUtil.a(this, predicate, i - b0, flag);
-        j += ContainerUtil.a(iinventory, predicate, i - j, flag);
-        j += ContainerUtil.a(this.getCarried(), predicate, i - j, flag);
-        if (this.getCarried().isEmpty()) {
-            this.setCarried(ItemStack.b);
-        }
-
-        return j;
-    }
-
-    private int i(ItemStack itemstack) {
-        int i = this.firstPartial(itemstack);
-        if (i == -1) {
-            i = this.getFirstEmptySlotIndex();
-        }
-
-        return i == -1 ? itemstack.getCount() : this.d(i, itemstack);
-    }
-
-    private int d(int i, ItemStack itemstack) {
-        Item item = itemstack.getItem();
-        int j = itemstack.getCount();
-        ItemStack itemstack1 = this.getItem(i);
-        if (itemstack1.isEmpty()) {
-            itemstack1 = new ItemStack(item, 0);
-            NBTTagCompound tag = itemstack.getTag();
-            if (tag != null) {
-                itemstack1.setTag(tag.clone());
-            }
-
-            this.setItem(i, itemstack1);
-        }
-
-        int k = j;
-        if (j > itemstack1.getMaxStackSize() - itemstack1.getCount()) {
-            k = itemstack1.getMaxStackSize() - itemstack1.getCount();
-        }
-
-        if (k > this.getMaxStackSize() - itemstack1.getCount()) {
-            k = this.getMaxStackSize() - itemstack1.getCount();
-        }
-
-        if (k != 0) {
-            j -= k;
-            itemstack1.add(k);
-            itemstack1.d(5);
-        }
-        return j;
-    }
-
-    @Override
-    public int firstPartial(ItemStack itemstack) {
-        if (this.isSimilarAndNotFull(this.getItem(this.itemInHandIndex), itemstack)) {
-            return this.itemInHandIndex;
-        } else if (this.isSimilarAndNotFull(this.getItem(40), itemstack)) {
-            return 40;
-        } else {
-            for (int i = 0; i < this.items.size(); ++i) {
-                if (this.isSimilarAndNotFull(this.items.get(i), itemstack)) {
-                    return i;
-                }
-            }
-
-            return -1;
-        }
-    }
-
-    @Override
-    public void j() {
-
-        for (List<ItemStack> itemStacks : this.f) {
-            for (int i = 0; i < itemStacks.size(); ++i) {
-                if (!itemStacks.get(i).isEmpty()) {
-                    itemStacks.get(i).a(this.player.world, this.player, i, this.itemInHandIndex == i);
-                }
-            }
-        }
-
-    }
-
-    @Override
-    public boolean pickup(ItemStack itemstack) {
-        return this.c(-1, itemstack);
-    }
-
-    @Override
-    public boolean c(int i, ItemStack itemstack) {
-        if (itemstack.isEmpty()) {
-            return false;
-        } else {
-            try {
-                if (itemstack.f()) {
-                    if (i == -1) {
-                        i = this.getFirstEmptySlotIndex();
-                    }
-
-                    if (i >= 0) {
-                        this.items.set(i, itemstack.cloneItemStack());
-                        this.items.get(i).d(5);
-                        itemstack.setCount(0);
-                        return true;
-                    } else if (this.player.abilities.canInstantlyBuild) {
-                        itemstack.setCount(0);
-                        return true;
-                    } else {
-                        return false;
-                    }
-                } else {
-                    int j;
-                    do {
-                        j = itemstack.getCount();
-                        if (i == -1) {
-                            itemstack.setCount(this.i(itemstack));
-                        } else {
-                            itemstack.setCount(this.d(i, itemstack));
-                        }
-                    } while(!itemstack.isEmpty() && itemstack.getCount() < j);
-
-                    if (itemstack.getCount() == j && this.player.abilities.canInstantlyBuild) {
-                        itemstack.setCount(0);
-                        return true;
-                    } else {
-                        return itemstack.getCount() < j;
-                    }
-                }
-            } catch (Throwable var6) {
-                CrashReport crashreport = CrashReport.a(var6, "Adding item to inventory");
-                CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Item being added");
-                crashreportsystemdetails.a("Item ID", Item.getId(itemstack.getItem()));
-                crashreportsystemdetails.a("Item data", itemstack.getDamage());
-                crashreportsystemdetails.a("Item name", () -> itemstack.getName().getString());
-                throw new ReportedException(crashreport);
-            }
-        }
-    }
-
-    @Override
-    public void a(World world, ItemStack itemstack) {
-        if (!world.isClientSide) {
-            while(!itemstack.isEmpty()) {
-                int i = this.firstPartial(itemstack);
-                if (i == -1) {
-                    i = this.getFirstEmptySlotIndex();
-                }
-
-                if (i == -1) {
-                    this.player.drop(itemstack, false);
-                    break;
-                }
-
-                int j = itemstack.getMaxStackSize() - this.getItem(i).getCount();
-                if (this.c(i, itemstack.cloneAndSubtract(j))) {
-                    ((EntityPlayer)this.player).playerConnection.sendPacket(new PacketPlayOutSetSlot(-2, i, this.getItem(i)));
-                }
-            }
-        }
-
-    }
-
-    @Override
-    public void f(ItemStack itemstack) {
-
-        for (List<ItemStack> list : this.f) {
-            for (int i = 0; i < list.size(); ++i) {
-                if (list.get(i) == itemstack) {
-                    list.set(i, ItemStack.b);
-                    break;
-                }
-            }
-        }
-    }
-
-    @Override
-    public float a(IBlockData iblockdata) {
-        return this.items.get(this.itemInHandIndex).a(iblockdata);
-    }
-
-    @Override
-    public NBTTagList a(NBTTagList nbttaglist) {
-        NBTTagCompound nbttagcompound;
-        int i;
-        for (i = 0; i < this.items.size(); ++i) {
-            if (!this.items.get(i).isEmpty()) {
-                nbttagcompound = new NBTTagCompound();
-                nbttagcompound.setByte("Slot", (byte) i);
-                this.items.get(i).save(nbttagcompound);
-                nbttaglist.add(nbttagcompound);
-            }
-        }
-
-        for (i = 0; i < this.armor.size(); ++i) {
-            if (!this.armor.get(i).isEmpty()) {
-                nbttagcompound = new NBTTagCompound();
-                nbttagcompound.setByte("Slot", (byte) (i + 100));
-                this.armor.get(i).save(nbttagcompound);
-                nbttaglist.add(nbttagcompound);
-            }
-        }
-
-        for (i = 0; i < this.extraSlots.size(); ++i) {
-            if (!this.extraSlots.get(i).isEmpty()) {
-                nbttagcompound = new NBTTagCompound();
-                nbttagcompound.setByte("Slot", (byte) (i + 150));
-                this.extraSlots.get(i).save(nbttagcompound);
-                nbttaglist.add(nbttagcompound);
-            }
-        }
-
-        return nbttaglist;
-    }
-
-    @Override
-    public void b(NBTTagList nbttaglist) {
-        this.items.clear();
-        this.armor.clear();
-        this.extraSlots.clear();
-
-        for(int i = 0; i < nbttaglist.size(); ++i) {
-            NBTTagCompound nbttagcompound = nbttaglist.getCompound(i);
-            int j = nbttagcompound.getByte("Slot") & 255;
-            ItemStack itemstack = ItemStack.a(nbttagcompound);
-            if (!itemstack.isEmpty()) {
-                if (j < this.items.size()) {
-                    this.items.set(j, itemstack);
-                } else if (j >= 100 && j < this.armor.size() + 100) {
-                    this.armor.set(j - 100, itemstack);
-                } else if (j >= 150 && j < this.extraSlots.size() + 150) {
-                    this.extraSlots.set(j - 150, itemstack);
-                }
-            }
-        }
-
-    }
-
-    @Override
-    public boolean isEmpty() {
-        Iterator<ItemStack> iterator = this.items.iterator();
-
-        ItemStack itemstack;
-        while (iterator.hasNext()) {
-            itemstack = iterator.next();
-            if (!itemstack.isEmpty()) {
-                return false;
-            }
-        }
-
-        iterator = this.armor.iterator();
-
-        while (iterator.hasNext()) {
-            itemstack = iterator.next();
-            if (!itemstack.isEmpty()) {
-                return false;
-            }
-        }
-
-        iterator = this.extraSlots.iterator();
-
-        while (iterator.hasNext()) {
-            itemstack = iterator.next();
-            if (!itemstack.isEmpty()) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    @Nullable
-    @Override
-    public IChatBaseComponent getCustomName() {
-        return null;
-    }
-
-    @Override
-    public void a(DamageSource damagesource, float f) {
-        if (f > 0.0F) {
-            f /= 4.0F;
-            if (f < 1.0F) {
-                f = 1.0F;
-            }
-
-            for (int i = 0; i < this.armor.size(); ++i) {
-                ItemStack itemstack = this.armor.get(0);
-                int index = i;
-                if ((!damagesource.isFire() || !itemstack.getItem().u()) && itemstack.getItem() instanceof ItemArmor) {
-                    itemstack.damage((int) f, this.player, (entityHuman) -> entityHuman.broadcastItemBreak(EnumItemSlot.a(EnumItemSlot.Function.ARMOR, index)));
-                }
-            }
-        }
-    }
-
-    @Override
-    public void dropContents() {
-        for (List<ItemStack> itemStacks : this.f) {
-            for (int i = 0; i < itemStacks.size(); ++i) {
-                ItemStack itemstack = itemStacks.get(i);
-                if (!itemstack.isEmpty()) {
-                    itemStacks.set(i, ItemStack.b);
-                    this.player.a(itemstack, true, false);
-                }
-            }
-        }
-    }
-
-    @Override
-    public boolean h(ItemStack itemstack) {
-        return this.f.stream().flatMap(List::stream).anyMatch(itemStack1 -> !itemStack1.isEmpty() && itemStack1.doMaterialsMatch(itemstack));
-    }
-
-    @Override
-    public void a(PlayerInventory playerinventory) {
-        for (int i = 0; i < playerinventory.getSize(); ++i) {
-            this.setItem(i, playerinventory.getItem(i));
-        }
-
-        this.itemInHandIndex = playerinventory.itemInHandIndex;
-    }
-
-    @Override
-    public void clear() {
-        this.f.forEach(List::clear);
-    }
-
-    @Override
-    public void a(AutoRecipeStackManager autorecipestackmanager) {
-        for (ItemStack itemstack : this.items) {
-            autorecipestackmanager.a(itemstack);
-        }
-    }
-
-}
@@ -1,73 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ Copyright (C) 2011-2021 lishid. All rights reserved.
-  ~
-  ~ This program is free software: you can redistribute it and/or modify
-  ~ it under the terms of the GNU General Public License as published by
-  ~ the Free Software Foundation, version 3.
-  ~
-  ~ 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 General Public License for more details.
-  ~
-  ~ You should have received a copy of the GNU General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <artifactId>openinvparent</artifactId>
-    <groupId>com.lishid</groupId>
-    <relativePath>../../pom.xml</relativePath>
-    <version>4.1.9-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>openinvadapter1_17_R1</artifactId>
-  <name>OpenInvAdapter1_17_R1</name>
-
-  <properties>
-    <maven.compiler.source>16</maven.compiler.source>
-    <maven.compiler.target>16</maven.compiler.target>
-  </properties>
-
-  <dependencies>
-    <dependency>
-      <artifactId>spigot</artifactId>
-      <groupId>org.spigotmc</groupId>
-      <scope>provided</scope>
-      <version>1.17-R0.1-SNAPSHOT</version>
-    </dependency>
-    <dependency>
-      <artifactId>openinvapi</artifactId>
-      <groupId>com.lishid</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>openinvplugincore</artifactId>
-      <groupId>com.lishid</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>annotations</artifactId>
-      <groupId>org.jetbrains</groupId>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
-        <!-- Cannot use minimizeJar until maven-shade-plugin 3.3.0 releases; ASM used does not support Java 16. -->
-        <configuration>
-          <minimizeJar>false</minimizeJar>
-        </configuration>
-      </plugin>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
-
-</project>
@@ -1,249 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_17_R1;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.internal.IAnySilentContainer;
-import java.lang.reflect.Field;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import net.minecraft.core.BlockPosition;
-import net.minecraft.network.chat.ChatMessage;
-import net.minecraft.network.chat.IChatBaseComponent;
-import net.minecraft.server.level.EntityPlayer;
-import net.minecraft.server.level.PlayerInteractManager;
-import net.minecraft.world.ITileInventory;
-import net.minecraft.world.InventoryLargeChest;
-import net.minecraft.world.TileInventory;
-import net.minecraft.world.entity.player.EntityHuman;
-import net.minecraft.world.entity.player.PlayerInventory;
-import net.minecraft.world.inventory.Container;
-import net.minecraft.world.inventory.ContainerChest;
-import net.minecraft.world.inventory.Containers;
-import net.minecraft.world.inventory.InventoryEnderChest;
-import net.minecraft.world.level.EnumGamemode;
-import net.minecraft.world.level.World;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.BlockBarrel;
-import net.minecraft.world.level.block.BlockChest;
-import net.minecraft.world.level.block.BlockChestTrapped;
-import net.minecraft.world.level.block.BlockShulkerBox;
-import net.minecraft.world.level.block.entity.TileEntity;
-import net.minecraft.world.level.block.entity.TileEntityChest;
-import net.minecraft.world.level.block.entity.TileEntityEnderChest;
-import net.minecraft.world.level.block.entity.TileEntityLootable;
-import net.minecraft.world.level.block.state.IBlockData;
-import net.minecraft.world.level.block.state.properties.BlockPropertyChestType;
-import org.bukkit.Material;
-import org.bukkit.Statistic;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryView;
-import org.jetbrains.annotations.NotNull;
-
-public class AnySilentContainer implements IAnySilentContainer {
-
-    private Field playerInteractManagerGamemode;
-
-    public AnySilentContainer() {
-        try {
-            this.playerInteractManagerGamemode = PlayerInteractManager.class.getDeclaredField("b");
-            this.playerInteractManagerGamemode.setAccessible(true);
-        } catch (NoSuchFieldException | SecurityException e) {
-            Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
-            logger.warning("Unable to directly write player gamemode! SilentChest will fail.");
-            logger.log(Level.WARNING, "Error obtaining gamemode field", e);
-        }
-    }
-
-    @Override
-    public boolean activateContainer(
-            @NotNull final Player bukkitPlayer,
-            final boolean silentchest,
-            @NotNull final org.bukkit.block.Block bukkitBlock) {
-
-        // Silent ender chest is API-only
-        if (silentchest && bukkitBlock.getType() == Material.ENDER_CHEST) {
-            bukkitPlayer.openInventory(bukkitPlayer.getEnderChest());
-            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
-            return true;
-        }
-
-        EntityPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
-
-        final World world = player.getWorld();
-        final BlockPosition blockPosition = new BlockPosition(bukkitBlock.getX(), bukkitBlock.getY(), bukkitBlock.getZ());
-        final TileEntity tile = world.getTileEntity(blockPosition);
-
-        if (tile == null) {
-            return false;
-        }
-
-        if (tile instanceof TileEntityEnderChest) {
-            // Anychest ender chest. See net.minecraft.world.level.block.BlockEnderChest
-            InventoryEnderChest enderChest = player.getEnderChest();
-            enderChest.a((TileEntityEnderChest) tile);
-            player.openContainer(new TileInventory((containerCounter, playerInventory, ignored) -> {
-                Containers<?> containers = PlayerDataManager.getContainers(enderChest.getSize());
-                int rows = enderChest.getSize() / 9;
-                return new ContainerChest(containers, containerCounter, playerInventory, enderChest, rows);
-            }, new ChatMessage("container.enderchest")));
-            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
-            return true;
-        }
-
-        if (!(tile instanceof ITileInventory tileInventory)) {
-            return false;
-        }
-
-        IBlockData blockData = world.getType(blockPosition);
-        Block block = blockData.getBlock();
-
-        if (block instanceof BlockChest) {
-
-            BlockPropertyChestType chestType = blockData.get(BlockChest.c);
-
-            if (chestType != BlockPropertyChestType.a) {
-
-                BlockPosition adjacentBlockPosition = blockPosition.shift(BlockChest.h(blockData));
-                IBlockData adjacentBlockData = world.getType(adjacentBlockPosition);
-
-                if (adjacentBlockData.getBlock() == block) {
-
-                    BlockPropertyChestType adjacentChestType = adjacentBlockData.get(BlockChest.c);
-
-                    if (adjacentChestType != BlockPropertyChestType.a && chestType != adjacentChestType
-                            && adjacentBlockData.get(BlockChest.b) == blockData.get(BlockChest.b)) {
-
-                        TileEntity adjacentTile = world.getTileEntity(adjacentBlockPosition);
-
-                        if (adjacentTile instanceof TileEntityChest && tileInventory instanceof  TileEntityChest) {
-                            TileEntityChest rightChest = chestType == BlockPropertyChestType.c ? ((TileEntityChest) tileInventory) : (TileEntityChest) adjacentTile;
-                            TileEntityChest leftChest = chestType == BlockPropertyChestType.c ? (TileEntityChest) adjacentTile : ((TileEntityChest) tileInventory);
-
-                            if (silentchest && (rightChest.g != null || leftChest.g != null)) {
-                                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
-                                return false;
-                            }
-
-                            tileInventory = new ITileInventory() {
-                                public Container createMenu(int containerCounter, PlayerInventory playerInventory, EntityHuman entityHuman) {
-                                    leftChest.d(playerInventory.l);
-                                    rightChest.d(playerInventory.l);
-                                    return ContainerChest.b(containerCounter, playerInventory, new InventoryLargeChest(rightChest, leftChest));
-                                }
-
-                                public IChatBaseComponent getScoreboardDisplayName() {
-                                    if (leftChest.hasCustomName()) {
-                                        return leftChest.getScoreboardDisplayName();
-                                    }
-                                    if (rightChest.hasCustomName()) {
-                                        return rightChest.getScoreboardDisplayName();
-                                    }
-                                    return new ChatMessage("container.chestDouble");
-                                }
-                            };
-                        }
-                    }
-                }
-            }
-
-            if (block instanceof BlockChestTrapped) {
-                bukkitPlayer.incrementStatistic(Statistic.TRAPPED_CHEST_TRIGGERED);
-            } else {
-                bukkitPlayer.incrementStatistic(Statistic.CHEST_OPENED);
-            }
-        }
-
-        if (block instanceof BlockShulkerBox) {
-            bukkitPlayer.incrementStatistic(Statistic.SHULKER_BOX_OPENED);
-        }
-
-        if (block instanceof BlockBarrel) {
-            bukkitPlayer.incrementStatistic(Statistic.OPEN_BARREL);
-        }
-
-        // AnyChest only - SilentChest not active, container unsupported, or unnecessary.
-        if (!silentchest || player.d.getGameMode() == EnumGamemode.d) {
-            player.openContainer(tileInventory);
-            return true;
-        }
-
-        // SilentChest requires access to setting players' gamemode directly.
-        if (this.playerInteractManagerGamemode == null) {
-            return false;
-        }
-
-        if (tile instanceof TileEntityLootable lootable) {
-            if (lootable.g != null) {
-                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
-                return false;
-            }
-        }
-
-        EnumGamemode gamemode = player.d.getGameMode();
-        this.forceGameMode(player, EnumGamemode.d);
-        player.openContainer(tileInventory);
-        this.forceGameMode(player, gamemode);
-        return true;
-    }
-
-    @Override
-    public void deactivateContainer(@NotNull final Player bukkitPlayer) {
-        if (this.playerInteractManagerGamemode == null) {
-            return;
-        }
-
-        InventoryView view = bukkitPlayer.getOpenInventory();
-        switch (view.getType()) {
-            case CHEST:
-            case ENDER_CHEST:
-            case SHULKER_BOX:
-            case BARREL:
-                break;
-            default:
-                return;
-        }
-
-        EntityPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
-
-        // Force game mode change without informing plugins or players.
-        EnumGamemode gamemode = player.d.getGameMode();
-        this.forceGameMode(player, EnumGamemode.d);
-
-        // See EntityPlayer#closeInventory - can't call or we'd recursively deactivate.
-        player.bV.b(player);
-        player.bU.a(player.bV);
-        player.bV = player.bU;
-
-        // Revert forced game mode.
-        this.forceGameMode(player, gamemode);
-    }
-
-    private void forceGameMode(final EntityPlayer player, final EnumGamemode gameMode) {
-        if (this.playerInteractManagerGamemode == null) {
-            // No need to warn repeatedly, error on startup and lack of function should be enough.
-            return;
-        }
-        try {
-            this.playerInteractManagerGamemode.setAccessible(true);
-            this.playerInteractManagerGamemode.set(player.d, gameMode);
-        } catch (IllegalArgumentException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-}
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_17_R1;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import net.minecraft.nbt.NBTCompressedStreamTools;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.server.level.EntityPlayer;
-import net.minecraft.world.level.storage.WorldNBTStorage;
-import org.apache.logging.log4j.LogManager;
-import org.bukkit.craftbukkit.v1_17_R1.CraftServer;
-import org.bukkit.craftbukkit.v1_17_R1.entity.CraftPlayer;
-
-public class OpenPlayer extends CraftPlayer {
-
-    public OpenPlayer(CraftServer server, EntityPlayer entity) {
-        super(server, entity);
-    }
-
-    @Override
-    public void loadData() {
-        // See CraftPlayer#loadData
-        NBTTagCompound loaded = this.server.getHandle().r.load(this.getHandle());
-        if (loaded != null) {
-            readExtraData(loaded);
-        }
-    }
-
-    @Override
-    public void saveData() {
-        EntityPlayer player = this.getHandle();
-        // See net.minecraft.world.level.storage.WorldNBTStorage#save(EntityHuman)
-        try {
-            WorldNBTStorage worldNBTStorage = player.c.getPlayerList().r;
-
-            NBTTagCompound playerData = player.save(new NBTTagCompound());
-            setExtraData(playerData);
-
-            if (!isOnline()) {
-                // Special case: save old vehicle data
-                NBTTagCompound oldData = worldNBTStorage.load(player);
-
-                if (oldData != null && oldData.hasKeyOfType("RootVehicle", 10)) {
-                    // See net.minecraft.server.PlayerList#a(NetworkManager, EntityPlayer) and net.minecraft.server.EntityPlayer#b(NBTTagCompound)
-                    playerData.set("RootVehicle", oldData.getCompound("RootVehicle"));
-                }
-            }
-
-            File file = new File(worldNBTStorage.getPlayerDir(), player.getUniqueIDString() + ".dat.tmp");
-            File file1 = new File(worldNBTStorage.getPlayerDir(), player.getUniqueIDString() + ".dat");
-
-            NBTCompressedStreamTools.a(playerData, new FileOutputStream(file));
-
-            if (file1.exists() && !file1.delete() || !file.renameTo(file1)) {
-                LogManager.getLogger().warn("Failed to save player data for {}", player.getDisplayName().getString());
-            }
-
-        } catch (Exception e) {
-            LogManager.getLogger().warn("Failed to save player data for {}", player.getDisplayName().getString());
-        }
-    }
-
-}
@@ -1,341 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_17_R1;
-
-import com.lishid.openinv.internal.ISpecialEnderChest;
-import java.util.List;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import net.minecraft.core.NonNullList;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraft.server.level.EntityPlayer;
-import net.minecraft.world.ContainerUtil;
-import net.minecraft.world.IInventoryListener;
-import net.minecraft.world.entity.player.AutoRecipeStackManager;
-import net.minecraft.world.entity.player.EntityHuman;
-import net.minecraft.world.inventory.InventoryEnderChest;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.entity.TileEntityEnderChest;
-import org.bukkit.Location;
-import org.bukkit.craftbukkit.v1_17_R1.entity.CraftHumanEntity;
-import org.bukkit.craftbukkit.v1_17_R1.inventory.CraftInventory;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryHolder;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class SpecialEnderChest extends InventoryEnderChest implements ISpecialEnderChest {
-
-    private final CraftInventory inventory;
-    private EntityPlayer owner;
-    private NonNullList<ItemStack> c;
-    private boolean playerOnline;
-
-    public SpecialEnderChest(final Player player, final Boolean online) {
-        super(PlayerDataManager.getHandle(player));
-        this.inventory = new CraftInventory(this);
-        this.owner = PlayerDataManager.getHandle(player);
-        this.playerOnline = online;
-        this.c = this.owner.getEnderChest().c;
-    }
-
-    @Override
-    public @NotNull CraftInventory getBukkitInventory() {
-        return inventory;
-    }
-
-    @Override
-    public boolean isInUse() {
-        return !this.getViewers().isEmpty();
-    }
-
-    @Override
-    public void setPlayerOffline() {
-        this.playerOnline = false;
-    }
-
-    @Override
-    public void setPlayerOnline(@NotNull final Player player) {
-        if (!this.playerOnline) {
-            try {
-                this.owner = PlayerDataManager.getHandle(player);
-                InventoryEnderChest enderChest = owner.getEnderChest();
-                for (int i = 0; i < enderChest.getSize(); ++i) {
-                    enderChest.setItem(i, this.c.get(i));
-                }
-                this.c = enderChest.c;
-                enderChest.transaction.addAll(this.transaction);
-            } catch (Exception ignored) {}
-            this.playerOnline = true;
-        }
-    }
-
-    @Override
-    public @NotNull Player getPlayer() {
-        return owner.getBukkitEntity();
-    }
-
-    @Override
-    public void update() {
-        this.owner.getEnderChest().update();
-    }
-
-    @Override
-    public List<ItemStack> getContents() {
-        return this.c;
-    }
-
-    @Override
-    public void onOpen(CraftHumanEntity who) {
-        super.onOpen(who);
-        this.owner.getEnderChest().onOpen(who);
-    }
-
-    @Override
-    public void onClose(CraftHumanEntity who) {
-        super.onClose(who);
-        this.owner.getEnderChest().onClose(who);
-    }
-
-    @Override
-    public List<HumanEntity> getViewers() {
-        return this.owner.getEnderChest().getViewers();
-    }
-
-    @Override
-    public boolean a(EntityHuman entityhuman) {
-        return true;
-    }
-
-    @Override
-    public void a(TileEntityEnderChest tileentityenderchest) {
-        this.owner.getEnderChest().a(tileentityenderchest);
-    }
-
-    @Override
-    public boolean b(TileEntityEnderChest tileentityenderchest) {
-        return this.owner.getEnderChest().b(tileentityenderchest);
-    }
-
-    @Override
-    public int getMaxStackSize() {
-        return this.owner.getEnderChest().getMaxStackSize();
-    }
-
-    @Override
-    public void setMaxStackSize(int i) {
-        this.owner.getEnderChest().setMaxStackSize(i);
-    }
-
-    @Override
-    public InventoryHolder getOwner() {
-        return this.owner.getEnderChest().getOwner();
-    }
-
-    @Override
-    public @Nullable Location getLocation() {
-        return null;
-    }
-
-    @Override
-    public void a(IInventoryListener iinventorylistener) {
-        this.owner.getEnderChest().a(iinventorylistener);
-    }
-
-    @Override
-    public void b(IInventoryListener iinventorylistener) {
-        this.owner.getEnderChest().b(iinventorylistener);
-    }
-
-    @Override
-    public ItemStack getItem(int i) {
-        return i >= 0 && i < this.c.size() ? this.c.get(i) : ItemStack.b;
-    }
-
-    @Override
-    public ItemStack splitStack(int i, int j) {
-        ItemStack itemstack = ContainerUtil.a(this.c, i, j);
-        if (!itemstack.isEmpty()) {
-            this.update();
-        }
-
-        return itemstack;
-    }
-
-    @Override
-    public ItemStack a(ItemStack itemstack) {
-        ItemStack itemstack1 = itemstack.cloneItemStack();
-        this.d(itemstack1);
-        if (itemstack1.isEmpty()) {
-            return ItemStack.b;
-        } else {
-            this.c(itemstack1);
-            return itemstack1.isEmpty() ? ItemStack.b : itemstack1;
-        }
-    }
-
-    private void c(ItemStack itemstack) {
-        for(int i = 0; i < this.getSize(); ++i) {
-            ItemStack itemstack1 = this.getItem(i);
-            if (itemstack1.isEmpty()) {
-                this.setItem(i, itemstack.cloneItemStack());
-                itemstack.setCount(0);
-                return;
-            }
-        }
-    }
-
-    private void d(ItemStack itemstack) {
-        for(int i = 0; i < this.getSize(); ++i) {
-            ItemStack itemstack1 = this.getItem(i);
-            if (ItemStack.e(itemstack1, itemstack)) {
-                this.a(itemstack, itemstack1);
-                if (itemstack.isEmpty()) {
-                    return;
-                }
-            }
-        }
-    }
-
-    private void a(ItemStack itemstack, ItemStack itemstack1) {
-        int i = Math.min(this.getMaxStackSize(), itemstack1.getMaxStackSize());
-        int j = Math.min(itemstack.getCount(), i - itemstack1.getCount());
-        if (j > 0) {
-            itemstack1.add(j);
-            itemstack.subtract(j);
-            this.update();
-        }
-    }
-
-    @Override
-    public ItemStack splitWithoutUpdate(int i) {
-        ItemStack itemstack = this.c.get(i);
-        if (itemstack.isEmpty()) {
-            return ItemStack.b;
-        } else {
-            this.c.set(i, ItemStack.b);
-            return itemstack;
-        }
-    }
-
-    @Override
-    public void setItem(int i, ItemStack itemstack) {
-        this.c.set(i, itemstack);
-        if (!itemstack.isEmpty() && itemstack.getCount() > this.getMaxStackSize()) {
-            itemstack.setCount(this.getMaxStackSize());
-        }
-
-        this.update();
-    }
-
-    @Override
-    public int getSize() {
-        return this.owner.getEnderChest().getSize();
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return this.c.stream().allMatch(ItemStack::isEmpty);
-    }
-
-    @Override
-    public void startOpen(EntityHuman entityhuman) {
-    }
-
-    @Override
-    public void closeContainer(EntityHuman entityhuman) {
-    }
-
-    @Override
-    public boolean b(int i, ItemStack itemstack) {
-        return true;
-    }
-
-    @Override
-    public void clear() {
-        this.c.clear();
-        this.update();
-    }
-
-    @Override
-    public void a(AutoRecipeStackManager autorecipestackmanager) {
-        for (ItemStack itemstack : this.c) {
-            autorecipestackmanager.b(itemstack);
-        }
-
-    }
-
-    @Override
-    public List<ItemStack> f() {
-        List<ItemStack> list = this.c.stream().filter(Predicate.not(ItemStack::isEmpty)).collect(Collectors.toList());
-        this.clear();
-        return list;
-    }
-
-    @Override
-    public ItemStack a(Item item, int i) {
-        ItemStack itemstack = new ItemStack(item, 0);
-
-        for(int j = this.getSize() - 1; j >= 0; --j) {
-            ItemStack itemstack1 = this.getItem(j);
-            if (itemstack1.getItem().equals(item)) {
-                int k = i - itemstack.getCount();
-                ItemStack itemstack2 = itemstack1.cloneAndSubtract(k);
-                itemstack.add(itemstack2.getCount());
-                if (itemstack.getCount() == i) {
-                    break;
-                }
-            }
-        }
-
-        if (!itemstack.isEmpty()) {
-            this.update();
-        }
-
-        return itemstack;
-    }
-
-    @Override
-    public boolean b(ItemStack itemStack) {
-        for (ItemStack itemStack1 : this.c) {
-            if (itemStack1.isEmpty() || ItemStack.e(itemStack1, itemStack) && itemStack1.getCount() < itemStack1.getMaxStackSize()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    @Override
-    public String toString() {
-        return this.c.stream().filter((itemStack) -> !itemStack.isEmpty()).collect(Collectors.toList()).toString();
-    }
-
-    @Override
-    public void a(NBTTagList nbttaglist) {
-        for(int i = 0; i < nbttaglist.size(); ++i) {
-            ItemStack itemstack = ItemStack.a(nbttaglist.getCompound(i));
-            if (!itemstack.isEmpty()) {
-                this.a(itemstack);
-            }
-        }
-
-    }
-
-}
@@ -1,777 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal.v1_17_R1;
-
-import com.google.common.collect.ImmutableList;
-import com.lishid.openinv.internal.ISpecialPlayerInventory;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import net.minecraft.CrashReport;
-import net.minecraft.CrashReportSystemDetails;
-import net.minecraft.ReportedException;
-import net.minecraft.core.NonNullList;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraft.network.chat.ChatMessage;
-import net.minecraft.network.chat.IChatBaseComponent;
-import net.minecraft.network.protocol.game.PacketPlayOutSetSlot;
-import net.minecraft.server.level.EntityPlayer;
-import net.minecraft.tags.Tag;
-import net.minecraft.world.ContainerUtil;
-import net.minecraft.world.IInventory;
-import net.minecraft.world.damagesource.DamageSource;
-import net.minecraft.world.entity.EnumItemSlot;
-import net.minecraft.world.entity.player.AutoRecipeStackManager;
-import net.minecraft.world.entity.player.EntityHuman;
-import net.minecraft.world.entity.player.PlayerInventory;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemArmor;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.state.IBlockData;
-import org.bukkit.Location;
-import org.bukkit.craftbukkit.v1_17_R1.entity.CraftHumanEntity;
-import org.bukkit.craftbukkit.v1_17_R1.inventory.CraftInventory;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryHolder;
-import org.jetbrains.annotations.NotNull;
-
-public class SpecialPlayerInventory extends PlayerInventory implements ISpecialPlayerInventory {
-
-    private final CraftInventory inventory;
-    private boolean playerOnline;
-    private EntityHuman l;
-    private NonNullList<ItemStack> h;
-    private NonNullList<ItemStack> i;
-    private NonNullList<ItemStack> j;
-    private List<NonNullList<ItemStack>> n;
-
-    public SpecialPlayerInventory(final Player bukkitPlayer, final Boolean online) {
-        super(PlayerDataManager.getHandle(bukkitPlayer));
-        this.inventory = new CraftInventory(this);
-        this.playerOnline = online;
-        this.l = super.l;
-        this.h = this.l.getInventory().h;
-        this.i = this.l.getInventory().i;
-        this.j = this.l.getInventory().j;
-        this.n = ImmutableList.of(this.h, this.i, this.j);
-    }
-
-    @Override
-    public void setPlayerOnline(@NotNull final Player player) {
-        if (!this.playerOnline) {
-            EntityPlayer entityPlayer = PlayerDataManager.getHandle(player);
-            entityPlayer.getInventory().transaction.addAll(this.transaction);
-            this.l = entityPlayer;
-            for (int i = 0; i < getSize(); ++i) {
-                this.l.getInventory().setItem(i, getRawItem(i));
-            }
-            this.l.getInventory().k = this.k;
-            this.h = this.l.getInventory().h;
-            this.i = this.l.getInventory().i;
-            this.j = this.l.getInventory().j;
-            this.n = ImmutableList.of(this.h, this.i, this.j);
-            this.playerOnline = true;
-        }
-    }
-
-    @Override
-    public boolean a(final EntityHuman entityhuman) {
-        return true;
-    }
-
-    @Override
-    public @NotNull CraftInventory getBukkitInventory() {
-        return this.inventory;
-    }
-
-    @Override
-    public ItemStack getItem(int i) {
-        List<ItemStack> list = this.h;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.i;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.j;
-        } else if (list == this.i) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            return ItemStack.b;
-        }
-
-        return list.get(i);
-    }
-
-    private ItemStack getRawItem(int i) {
-        NonNullList<ItemStack> list = null;
-        for (NonNullList<ItemStack> next : this.n) {
-            if (i < next.size()) {
-                list = next;
-                break;
-            }
-            i -= next.size();
-        }
-
-        return list == null ? ItemStack.b : list.get(i);
-    }
-
-    @Override
-    public IChatBaseComponent getDisplayName() {
-        return new ChatMessage(this.l.getName());
-    }
-
-    @Override
-    public boolean hasCustomName() {
-        return false;
-    }
-
-    private int getReversedArmorSlotNum(final int i) {
-        if (i == 0) {
-            return 3;
-        }
-        if (i == 1) {
-            return 2;
-        }
-        if (i == 2) {
-            return 1;
-        }
-        if (i == 3) {
-            return 0;
-        }
-        return i;
-    }
-
-    private int getReversedItemSlotNum(final int i) {
-        if (i >= 27) {
-            return i - 27;
-        }
-        return i + 9;
-    }
-
-    @Override
-    public int getSize() {
-        return 45;
-    }
-
-    @Override
-    public boolean isInUse() {
-        return !this.getViewers().isEmpty();
-    }
-
-    @Override
-    public void setItem(int i, final ItemStack itemstack) {
-        List<ItemStack> list = this.h;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.i;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.j;
-        } else if (list == this.i) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            this.l.drop(itemstack, true);
-            return;
-        }
-
-        list.set(i, itemstack);
-    }
-
-    @Override
-    public void setPlayerOffline() {
-        this.playerOnline = false;
-    }
-
-    @Override
-    public @NotNull HumanEntity getPlayer() {
-        return this.l.getBukkitEntity();
-    }
-
-    @Override
-    public ItemStack splitStack(int i, final int j) {
-        List<ItemStack> list = this.h;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.i;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.j;
-        } else if (list == this.i) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            return ItemStack.b;
-        }
-
-        return list.get(i).isEmpty() ? ItemStack.b : ContainerUtil.a(list, i, j);
-    }
-
-    @Override
-    public ItemStack splitWithoutUpdate(int i) {
-        List<ItemStack> list = this.h;
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.i;
-        } else {
-            i = this.getReversedItemSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            i -= list.size();
-            list = this.j;
-        } else if (list == this.i) {
-            i = this.getReversedArmorSlotNum(i);
-        }
-
-        if (i >= list.size()) {
-            return ItemStack.b;
-        }
-
-        if (!list.get(i).isEmpty()) {
-            ItemStack itemstack = list.get(i);
-
-            list.set(i, ItemStack.b);
-            return itemstack;
-        }
-
-        return ItemStack.b;
-    }
-
-    @Override
-    public List<ItemStack> getContents() {
-        return this.n.stream().flatMap(Collection::stream).collect(Collectors.toList());
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return this.n.stream().flatMap(Collection::stream).allMatch(ItemStack::isEmpty);
-    }
-
-    @Override
-    public List<ItemStack> getArmorContents() {
-        return this.i;
-    }
-
-    @Override
-    public void onOpen(CraftHumanEntity who) {
-        this.transaction.add(who);
-        this.l.getInventory().transaction.add(who);
-    }
-
-    @Override
-    public void onClose(CraftHumanEntity who) {
-        this.transaction.remove(who);
-        this.l.getInventory().transaction.remove(who);
-    }
-
-    @Override
-    public List<HumanEntity> getViewers() {
-        return this.transaction;
-    }
-
-    @Override
-    public InventoryHolder getOwner() {
-        return this.l.getBukkitEntity();
-    }
-
-    public Location getLocation() {
-        return this.l.getBukkitEntity().getLocation();
-    }
-
-    /* Below this point largely just copied out of NMS to redirect to our overridden variables. */
-
-    @Override
-    public ItemStack getItemInHand() {
-        return d(this.k) ? this.h.get(this.k) : ItemStack.b;
-    }
-
-    private boolean isSimilarAndNotFull(ItemStack itemstack, ItemStack itemstack1) {
-        return !itemstack.isEmpty() && ItemStack.e(itemstack, itemstack1) && itemstack.isStackable() && itemstack.getCount() < itemstack.getMaxStackSize() && itemstack.getCount() < this.getMaxStackSize();
-    }
-
-    @Override
-    public int canHold(ItemStack itemstack) {
-        int remains = itemstack.getCount();
-
-        for(int i = 0; i < this.h.size(); ++i) {
-            ItemStack itemstack1 = this.getItem(i);
-            if (itemstack1.isEmpty()) {
-                return itemstack.getCount();
-            }
-
-            if (this.isSimilarAndNotFull(itemstack1, itemstack)) {
-                remains -= (Math.min(itemstack1.getMaxStackSize(), this.getMaxStackSize())) - itemstack1.getCount();
-            }
-
-            if (remains <= 0) {
-                return itemstack.getCount();
-            }
-        }
-
-        ItemStack offhandItemStack = this.getItem(this.h.size() + this.i.size());
-        if (this.isSimilarAndNotFull(offhandItemStack, itemstack)) {
-            remains -= (Math.min(offhandItemStack.getMaxStackSize(), this.getMaxStackSize())) - offhandItemStack.getCount();
-        }
-
-        return remains <= 0 ? itemstack.getCount() : itemstack.getCount() - remains;
-    }
-
-    @Override
-    public int getFirstEmptySlotIndex() {
-        for(int i = 0; i < this.h.size(); ++i) {
-            if (this.h.get(i).isEmpty()) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    @Override
-    public void a(ItemStack itemstack) {
-        int i = this.b(itemstack);
-        if (d(i)) {
-            this.k = i;
-        } else if (i == -1) {
-            this.k = this.i();
-            if (!this.h.get(this.k).isEmpty()) {
-                int j = this.getFirstEmptySlotIndex();
-                if (j != -1) {
-                    this.h.set(j, this.h.get(this.k));
-                }
-            }
-
-            this.h.set(this.k, itemstack);
-        } else {
-            this.c(i);
-        }
-
-    }
-
-    @Override
-    public void c(int i) {
-        this.k = this.i();
-        ItemStack itemstack = this.h.get(this.k);
-        this.h.set(this.k, this.h.get(i));
-        this.h.set(i, itemstack);
-    }
-
-    @Override
-    public int b(ItemStack itemstack) {
-        for (int i = 0; i < this.h.size(); ++i) {
-            if (!this.h.get(i).isEmpty() && ItemStack.e(itemstack, this.h.get(i))) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    @Override
-    public int c(ItemStack itemstack) {
-        for (int i = 0; i < this.h.size(); ++i) {
-            ItemStack itemstack1 = this.h.get(i);
-            if (!this.h.get(i).isEmpty() && ItemStack.e(itemstack, this.h.get(i)) && !this.h.get(i).g() && !itemstack1.hasEnchantments() && !itemstack1.hasName()) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    @Override
-    public int i() {
-        int i;
-        int j;
-        for (j = 0; j < 9; ++j) {
-            i = (this.k + j) % 9;
-            if (this.h.get(i).isEmpty()) {
-                return i;
-            }
-        }
-
-        for (j = 0; j < 9; ++j) {
-            i = (this.k + j) % 9;
-            if (!this.h.get(i).hasEnchantments()) {
-                return i;
-            }
-        }
-
-        return this.k;
-    }
-
-    @Override
-    public void a(double d0) {
-        if (d0 > 0.0D) {
-            d0 = 1.0D;
-        }
-
-        if (d0 < 0.0D) {
-            d0 = -1.0D;
-        }
-
-        this.k = (int) (this.k - d0);
-
-        while (this.k < 0) {
-            this.k += 9;
-        }
-
-        while (this.k >= 9) {
-            this.k -= 9;
-        }
-
-    }
-
-    @Override
-    public int a(Predicate<ItemStack> predicate, int i, IInventory iinventory) {
-        byte b0 = 0;
-        boolean flag = i == 0;
-        int j = b0 + ContainerUtil.a(this, predicate, i - b0, flag);
-        j += ContainerUtil.a(iinventory, predicate, i - j, flag);
-        ItemStack itemstack = this.l.bV.getCarried();
-        j += ContainerUtil.a(itemstack, predicate, i - j, flag);
-        if (itemstack.isEmpty()) {
-            this.l.bV.setCarried(ItemStack.b);
-        }
-
-        return j;
-    }
-
-    private int i(ItemStack itemstack) {
-        int i = this.firstPartial(itemstack);
-        if (i == -1) {
-            i = this.getFirstEmptySlotIndex();
-        }
-
-        return i == -1 ? itemstack.getCount() : this.d(i, itemstack);
-    }
-
-    private int d(int i, ItemStack itemstack) {
-        Item item = itemstack.getItem();
-        int j = itemstack.getCount();
-        ItemStack itemstack1 = this.getItem(i);
-        if (itemstack1.isEmpty()) {
-            itemstack1 = new ItemStack(item, 0);
-            if (itemstack.hasTag()) {
-                itemstack1.setTag(Objects.requireNonNull(itemstack.getTag()).clone());
-            }
-
-            this.setItem(i, itemstack1);
-        }
-
-        k = Math.min(j, itemstack1.getMaxStackSize() - itemstack1.getCount());
-
-        if (k > this.getMaxStackSize() - itemstack1.getCount()) {
-            k = this.getMaxStackSize() - itemstack1.getCount();
-        }
-
-        if (k != 0) {
-            j -= k;
-            itemstack1.add(k);
-            itemstack1.d(5);
-        }
-
-        return j;
-    }
-
-    @Override
-    public int firstPartial(ItemStack itemstack) {
-        if (this.isSimilarAndNotFull(this.getItem(this.k), itemstack)) {
-            return this.k;
-        } else if (this.isSimilarAndNotFull(this.getItem(40), itemstack)) {
-            return 40;
-        } else {
-            for(int i = 0; i < this.h.size(); ++i) {
-                if (this.isSimilarAndNotFull(this.h.get(i), itemstack)) {
-                    return i;
-                }
-            }
-
-            return -1;
-        }
-    }
-
-    @Override
-    public void j() {
-        for (NonNullList<ItemStack> nonNullList : this.n) {
-            for (int i = 0; i < nonNullList.size(); ++i) {
-                if (!nonNullList.get(i).isEmpty()) {
-                    nonNullList.get(i).a(this.l.t, this.l, i, this.k == i);
-                }
-            }
-        }
-
-    }
-
-    @Override
-    public boolean pickup(ItemStack itemStack) {
-        return this.c(-1, itemStack);
-    }
-
-    @Override
-    public boolean c(int i, ItemStack itemStack) {
-        if (itemStack.isEmpty()) {
-            return false;
-        } else {
-            try {
-                if (itemStack.g()) {
-                    if (i == -1) {
-                        i = this.getFirstEmptySlotIndex();
-                    }
-
-                    if (i >= 0) {
-                        this.h.set(i, itemStack.cloneItemStack());
-                        this.h.get(i).d(5);
-                        itemStack.setCount(0);
-                        return true;
-                    } else if (this.l.getAbilities().d) {
-                        itemStack.setCount(0);
-                        return true;
-                    } else {
-                        return false;
-                    }
-                } else {
-                    int j;
-                    do {
-                        j = itemStack.getCount();
-                        if (i == -1) {
-                            itemStack.setCount(this.i(itemStack));
-                        } else {
-                            itemStack.setCount(this.d(i, itemStack));
-                        }
-                    } while(!itemStack.isEmpty() && itemStack.getCount() < j);
-
-                    if (itemStack.getCount() == j && this.l.getAbilities().d) {
-                        itemStack.setCount(0);
-                        return true;
-                    } else {
-                        return itemStack.getCount() < j;
-                    }
-                }
-            } catch (Throwable var6) {
-                CrashReport crashreport = CrashReport.a(var6, "Adding item to inventory");
-                CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Item being added");
-                crashreportsystemdetails.a("Item ID", Item.getId(itemStack.getItem()));
-                crashreportsystemdetails.a("Item data", itemStack.getDamage());
-                crashreportsystemdetails.a("Item name", () -> itemStack.getName().getString());
-                throw new ReportedException(crashreport);
-            }
-        }
-    }
-
-    @Override
-    public void f(ItemStack itemStack) {
-        this.a(itemStack, true);
-    }
-
-    @Override
-    public void a(ItemStack itemStack, boolean flag) {
-        while(true) {
-            if (!itemStack.isEmpty()) {
-                int i = this.firstPartial(itemStack);
-                if (i == -1) {
-                    i = this.getFirstEmptySlotIndex();
-                }
-
-                if (i != -1) {
-                    int j = itemStack.getMaxStackSize() - this.getItem(i).getCount();
-                    if (this.c(i, itemStack.cloneAndSubtract(j)) && flag && this.l instanceof EntityPlayer) {
-                        ((EntityPlayer)this.l).b.sendPacket(new PacketPlayOutSetSlot(-2, i, this.getItem(i)));
-                    }
-                    continue;
-                }
-
-                this.l.drop(itemStack, false);
-            }
-
-            return;
-        }
-    }
-
-    @Override
-    public void g(ItemStack itemStack) {
-        for (NonNullList<ItemStack> nonNullList : this.n) {
-            for (int i = 0; i < nonNullList.size(); ++i) {
-                if (nonNullList.get(i) == itemStack) {
-                    nonNullList.set(i, ItemStack.b);
-                    break;
-                }
-            }
-        }
-    }
-
-    @Override
-    public float a(IBlockData iBlockData) {
-        return this.h.get(this.k).a(iBlockData);
-    }
-
-    @Override
-    public NBTTagList a(NBTTagList nbtTagList) {
-        NBTTagCompound nbttagcompound;
-        int i;
-        for(i = 0; i < this.h.size(); ++i) {
-            if (!this.h.get(i).isEmpty()) {
-                nbttagcompound = new NBTTagCompound();
-                nbttagcompound.setByte("Slot", (byte)i);
-                this.h.get(i).save(nbttagcompound);
-                nbtTagList.add(nbttagcompound);
-            }
-        }
-
-        for(i = 0; i < this.i.size(); ++i) {
-            if (!this.i.get(i).isEmpty()) {
-                nbttagcompound = new NBTTagCompound();
-                nbttagcompound.setByte("Slot", (byte)(i + 100));
-                this.i.get(i).save(nbttagcompound);
-                nbtTagList.add(nbttagcompound);
-            }
-        }
-
-        for(i = 0; i < this.j.size(); ++i) {
-            if (!this.j.get(i).isEmpty()) {
-                nbttagcompound = new NBTTagCompound();
-                nbttagcompound.setByte("Slot", (byte)(i + 150));
-                this.j.get(i).save(nbttagcompound);
-                nbtTagList.add(nbttagcompound);
-            }
-        }
-
-        return nbtTagList;
-    }
-
-    @Override
-    public void b(NBTTagList nbtTagList) {
-        this.h.clear();
-        this.i.clear();
-        this.j.clear();
-
-        for(int i = 0; i < nbtTagList.size(); ++i) {
-            NBTTagCompound nbttagcompound = nbtTagList.getCompound(i);
-            int j = nbttagcompound.getByte("Slot") & 255;
-            ItemStack itemstack = ItemStack.a(nbttagcompound);
-            if (!itemstack.isEmpty()) {
-                if (j < this.h.size()) {
-                    this.h.set(j, itemstack);
-                } else if (j >= 100 && j < this.i.size() + 100) {
-                    this.i.set(j - 100, itemstack);
-                } else if (j >= 150 && j < this.j.size() + 150) {
-                    this.j.set(j - 150, itemstack);
-                }
-            }
-        }
-
-    }
-
-    @Override
-    public ItemStack e(int i) {
-        return this.i.get(i);
-    }
-
-    @Override
-    public void a(DamageSource damageSource, float f, int[] intArray) {
-        if (f > 0.0F) {
-            f /= 4.0F;
-            if (f < 1.0F) {
-                f = 1.0F;
-            }
-
-            for (int index : intArray) {
-                ItemStack itemstack = this.i.get(index);
-                if ((!damageSource.isFire() || !itemstack.getItem().w()) && itemstack.getItem() instanceof ItemArmor) {
-                    itemstack.damage((int) f, this.l, (entityHuman) -> entityHuman.broadcastItemBreak(EnumItemSlot.a(EnumItemSlot.Function.b, index)));
-                }
-            }
-        }
-
-    }
-
-    @Override
-    public void dropContents() {
-        for (List<ItemStack> list : this.n) {
-            for (int i = 0; i < list.size(); ++i) {
-                ItemStack itemstack = list.get(i);
-                if (!itemstack.isEmpty()) {
-                    list.set(i, ItemStack.b);
-                    this.l.a(itemstack, true, false);
-                }
-            }
-        }
-    }
-
-    @Override
-    public boolean h(ItemStack itemStack) {
-        return this.n.stream()
-                .flatMap(Collection::stream)
-                .anyMatch(itemStack1 -> !itemStack1.isEmpty() && itemStack1.doMaterialsMatch(itemStack));
-    }
-
-    @Override
-    public boolean a(Tag<Item> tag) {
-        return this.n.stream()
-                .flatMap(Collection::stream)
-                .anyMatch(itemStack -> !itemStack.isEmpty() && itemStack.a(tag));
-    }
-
-    @Override
-    public void a(PlayerInventory playerInventory) {
-        for(int i = 0; i < this.getSize(); ++i) {
-            this.setItem(i, playerInventory.getItem(i));
-        }
-
-        this.k = playerInventory.k;
-    }
-
-    @Override
-    public void clear() {
-        for (List<ItemStack> list : this.n) {
-            list.clear();
-        }
-    }
-
-    @Override
-    public void a(AutoRecipeStackManager autoRecipeStackManager) {
-        for (ItemStack itemstack : this.h) {
-            autoRecipeStackManager.a(itemstack);
-        }
-    }
-
-}
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_19_R3;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IAnySilentContainer;
+import com.lishid.openinv.util.ReflectionHelper;
+import java.lang.reflect.Field;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.level.ServerPlayerGameMode;
+import net.minecraft.world.MenuProvider;
+import net.minecraft.world.SimpleMenuProvider;
+import net.minecraft.world.entity.monster.Shulker;
+import net.minecraft.world.inventory.ChestMenu;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.inventory.PlayerEnderChestContainer;
+import net.minecraft.world.level.GameType;
+import net.minecraft.world.level.block.BarrelBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.ShulkerBoxBlock;
+import net.minecraft.world.level.block.TrappedChestBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.EnderChestBlockEntity;
+import net.minecraft.world.level.block.entity.RandomizableContainerBlockEntity;
+import net.minecraft.world.level.block.entity.ShulkerBoxBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.AABB;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.Statistic;
+import org.bukkit.block.ShulkerBox;
+import org.bukkit.craftbukkit.v1_19_R3.CraftWorld;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class AnySilentContainer implements IAnySilentContainer {
+
+    private @Nullable Field serverPlayerGameModeGameType;
+
+    public AnySilentContainer() {
+        try {
+            try {
+                this.serverPlayerGameModeGameType = ServerPlayerGameMode.class.getDeclaredField("b");
+                this.serverPlayerGameModeGameType.setAccessible(true);
+            } catch (NoSuchFieldException e) {
+                Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
+                logger.warning("ServerPlayerGameMode#gameModeForPlayer's obfuscated name has changed!");
+                logger.warning("Please report this at https://github.com/Jikoo/OpenInv/issues");
+                logger.warning("Attempting to fall through using reflection. Please verify that SilentContainer does not fail.");
+                // N.B. gameModeForPlayer is (for now) declared before previousGameModeForPlayer so silent shouldn't break.
+                this.serverPlayerGameModeGameType = ReflectionHelper.grabFieldByType(ServerPlayerGameMode.class, GameType.class);
+            }
+        } catch (SecurityException e) {
+            Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
+            logger.warning("Unable to directly write player game mode! SilentContainer will fail.");
+            logger.log(Level.WARNING, "Error obtaining GameType field", e);
+        }
+    }
+
+    @Override
+    public boolean isShulkerBlocked(@NotNull ShulkerBox shulkerBox) {
+        org.bukkit.World bukkitWorld = shulkerBox.getWorld();
+        if (!(bukkitWorld instanceof CraftWorld)) {
+            bukkitWorld = Bukkit.getWorld(bukkitWorld.getUID());
+        }
+
+        if (!(bukkitWorld instanceof CraftWorld craftWorld)) {
+            Exception exception = new IllegalStateException("AnySilentContainer access attempted on an unknown world!");
+            OpenInv.getPlugin(OpenInv.class).getLogger().log(Level.WARNING, exception.getMessage(), exception);
+            return false;
+        }
+
+        final ServerLevel world = craftWorld.getHandle();
+        final BlockPos blockPosition = new BlockPos(shulkerBox.getX(), shulkerBox.getY(), shulkerBox.getZ());
+        final BlockEntity tile = world.getBlockEntity(blockPosition);
+
+        if (!(tile instanceof ShulkerBoxBlockEntity shulkerBoxBlockEntity)
+                || shulkerBoxBlockEntity.getAnimationStatus() != ShulkerBoxBlockEntity.AnimationStatus.CLOSED) {
+            return false;
+        }
+
+        BlockState blockState = world.getBlockState(blockPosition);
+
+        // See net.minecraft.world.level.block.ShulkerBoxBlock#canOpen
+        AABB boundingBox = Shulker.getProgressDeltaAabb(blockState.getValue(ShulkerBoxBlock.FACING), 0.0F, 0.5F)
+                .move(blockPosition)
+                .deflate(1.0E-6D);
+        return !world.noCollision(boundingBox);
+    }
+
+    @Override
+    public boolean activateContainer(
+            @NotNull final Player bukkitPlayer,
+            final boolean silentchest,
+            @NotNull final org.bukkit.block.Block bukkitBlock) {
+
+        // Silent ender chest is API-only
+        if (silentchest && bukkitBlock.getType() == Material.ENDER_CHEST) {
+            bukkitPlayer.openInventory(bukkitPlayer.getEnderChest());
+            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
+            return true;
+        }
+
+        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+
+        final ServerLevel level = player.getLevel();
+        final BlockPos blockPos = new BlockPos(bukkitBlock.getX(), bukkitBlock.getY(), bukkitBlock.getZ());
+        final BlockEntity blockEntity = level.getBlockEntity(blockPos);
+
+        if (blockEntity == null) {
+            return false;
+        }
+
+        if (blockEntity instanceof EnderChestBlockEntity enderChestTile) {
+            // Anychest ender chest. See net.minecraft.world.level.block.EnderChestBlock
+            PlayerEnderChestContainer enderChest = player.getEnderChestInventory();
+            enderChest.setActiveChest(enderChestTile);
+            player.openMenu(new SimpleMenuProvider((containerCounter, playerInventory, ignored) -> {
+                MenuType<?> containers = PlayerDataManager.getContainers(enderChest.getContainerSize());
+                int rows = enderChest.getContainerSize() / 9;
+                return new ChestMenu(containers, containerCounter, playerInventory, enderChest, rows);
+            }, Component.translatable(("container.enderchest"))));
+            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
+            return true;
+        }
+
+        if (!(blockEntity instanceof MenuProvider menuProvider)) {
+            return false;
+        }
+
+        BlockState blockState = level.getBlockState(blockPos);
+        Block block = blockState.getBlock();
+
+        if (block instanceof ChestBlock chestBlock) {
+
+            // boolean flag: do not check if chest is blocked
+            menuProvider = chestBlock.getMenuProvider(blockState, level, blockPos, true);
+
+            if (menuProvider == null) {
+                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
+                return false;
+            }
+
+            if (block instanceof TrappedChestBlock) {
+                bukkitPlayer.incrementStatistic(Statistic.TRAPPED_CHEST_TRIGGERED);
+            } else {
+                bukkitPlayer.incrementStatistic(Statistic.CHEST_OPENED);
+            }
+        }
+
+        if (block instanceof ShulkerBoxBlock) {
+            bukkitPlayer.incrementStatistic(Statistic.SHULKER_BOX_OPENED);
+        }
+
+        if (block instanceof BarrelBlock) {
+            bukkitPlayer.incrementStatistic(Statistic.OPEN_BARREL);
+        }
+
+        // AnyChest only - SilentChest not active, container unsupported, or unnecessary.
+        if (!silentchest || player.gameMode.getGameModeForPlayer() == GameType.SPECTATOR) {
+            player.openMenu(menuProvider);
+            return true;
+        }
+
+        // SilentChest requires access to setting players' game mode directly.
+        if (this.serverPlayerGameModeGameType == null) {
+            return false;
+        }
+
+        if (blockEntity instanceof RandomizableContainerBlockEntity lootable) {
+            if (lootable.lootTable != null) {
+                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
+                return false;
+            }
+        }
+
+        GameType gameType = player.gameMode.getGameModeForPlayer();
+        this.forceGameType(player, GameType.SPECTATOR);
+        player.openMenu(menuProvider);
+        this.forceGameType(player, gameType);
+        return true;
+    }
+
+    @Override
+    public void deactivateContainer(@NotNull final Player bukkitPlayer) {
+        if (this.serverPlayerGameModeGameType == null || bukkitPlayer.getGameMode() == GameMode.SPECTATOR) {
+            return;
+        }
+
+        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+
+        // Force game mode change without informing plugins or players.
+        // Regular game mode set calls GameModeChangeEvent and is cancellable.
+        GameType gameType = player.gameMode.getGameModeForPlayer();
+        this.forceGameType(player, GameType.SPECTATOR);
+
+        // ServerPlayer#closeContainer cannot be called without entering an
+        // infinite loop because this method is called during inventory close.
+        // From ServerPlayer#closeContainer -> CraftEventFactory#handleInventoryCloseEvent
+        player.containerMenu.transferTo(player.inventoryMenu, player.getBukkitEntity());
+        // From ServerPlayer#closeContainer
+        player.doCloseContainer();
+        // Regular inventory close will handle the rest - packet sending, etc.
+
+        // Revert forced game mode.
+        this.forceGameType(player, gameType);
+    }
+
+    private void forceGameType(final ServerPlayer player, final GameType gameMode) {
+        if (this.serverPlayerGameModeGameType == null) {
+            // No need to warn repeatedly, error on startup and lack of function should be enough.
+            return;
+        }
+        try {
+            this.serverPlayerGameModeGameType.setAccessible(true);
+            this.serverPlayerGameModeGameType.set(player.gameMode, gameMode);
+        } catch (IllegalArgumentException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+}
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_19_R3;
+
+import net.minecraft.Util;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtIo;
+import net.minecraft.nbt.NumericTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.storage.PlayerDataStorage;
+import org.apache.logging.log4j.LogManager;
+import org.bukkit.craftbukkit.v1_19_R3.CraftServer;
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftPlayer;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.util.Set;
+import java.util.UUID;
+
+public class OpenPlayer extends CraftPlayer {
+
+    private static final Set<String> RESET_TAGS = Set.of(
+        // net.minecraft.world.Entity#saveWithoutId(CompoundTag)
+        "CustomName",
+        "CustomNameVisible",
+        "Silent",
+        "NoGravity",
+        "Glowing",
+        "TicksFrozen",
+        "HasVisualFire",
+        "Tags",
+        "Passengers",
+        // net.minecraft.server.level.ServerPlayer#addAdditionalSaveData(CompoundTag)
+        // Intentional omissions to prevent mount loss: Attach, Entity, and RootVehicle
+        "warden_spawn_tracker",
+        "enteredNetherPosition",
+        "SpawnX",
+        "SpawnY",
+        "SpawnZ",
+        "SpawnForced",
+        "SpawnAngle",
+        "SpawnDimension",
+        // net.minecraft.world.entity.player.Player#addAdditionalSaveData(CompoundTag)
+        "ShoulderEntityLeft",
+        "ShoulderEntityRight",
+        "LastDeathLocation",
+        // net.minecraft.world.entity.LivingEntity#addAdditionalSaveData(CompoundTag)
+        "ActiveEffects",
+        "SleepingX",
+        "SleepingY",
+        "SleepingZ",
+        "Brain"
+    );
+
+    public OpenPlayer(CraftServer server, ServerPlayer entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public void loadData() {
+        // See CraftPlayer#loadData
+        ServerPlayer serverPlayer = getHandle();
+        // The server's own storage, never the hookable PlayerList.playerIo, so an offline edit always targets the main profile
+        CompoundTag loaded = this.server.getServer().playerDataStorage.load(serverPlayer);
+        if (loaded != null) {
+            serverPlayer.readAdditionalSaveData(loaded);
+            serverPlayer.loadGameTypes(loaded);
+        }
+    }
+
+    @Override
+    public void saveData() {
+        ServerPlayer player = this.getHandle();
+        // An offline save is a read-modify-write of the stored profile: hold the Utilities-OG player lock that MyWorlds and
+        // DiamondBank hold for theirs, so the two never interleave (no lock without that plugin, nothing else writes then)
+        boolean offline = !isOnline();
+        if (offline) {
+            UtilitiesLock.lock(player.getUUID());
+        }
+        // See net.minecraft.world.level.storage.PlayerDataStorage#save(EntityHuman)
+        try {
+            PlayerDataStorage worldNBTStorage = player.server.playerDataStorage;
+
+            // Read without applying: load(Player) would push the stored inventory back over the edit being saved
+            CompoundTag oldData = offline ? readStoredTag(worldNBTStorage, player) : null;
+            CompoundTag playerData = getWritableTag(oldData);
+            playerData = player.saveWithoutId(playerData);
+            setExtraData(playerData);
+
+            if (oldData != null) {
+                // Revert certain special data values when offline.
+                revertSpecialValues(playerData, oldData);
+            }
+
+            if (saveThroughStorageApi(worldNBTStorage, player.getUUID(), playerData)) {
+                return;
+            }
+            File file = File.createTempFile(player.getStringUUID() + "-", ".dat", worldNBTStorage.getPlayerDir());
+            NbtIo.writeCompressed(playerData, file);
+            File file1 = new File(worldNBTStorage.getPlayerDir(), player.getStringUUID() + ".dat");
+            File file2 = new File(worldNBTStorage.getPlayerDir(), player.getStringUUID() + ".dat_old");
+            Util.safeReplaceFile(file1, file, file2);
+        } catch (Exception e) {
+            LogManager.getLogger().warn("Failed to save player data for {}: {}", player.getScoreboardName(), e);
+        } finally {
+            if (offline) {
+                UtilitiesLock.unlock(player.getUUID());
+            }
+        }
+    }
+
+    // Utilities-OG's per player lock, reached by reflection so OpenInv needs no compile dependency on it
+    private static final class UtilitiesLock {
+        private static final Method LOCK;
+        private static final Method UNLOCK;
+
+        static {
+            Method lock = null;
+            Method unlock = null;
+            try {
+                Class<?> utilities = Class.forName("net.trueog.utilitiesog.UtilitiesOG", true, OpenPlayer.class.getClassLoader());
+                lock = utilities.getMethod("lockPlayerData", UUID.class);
+                unlock = utilities.getMethod("unlockPlayerData", UUID.class);
+            } catch (ReflectiveOperationException e) {
+                // Utilities-OG is not installed, offline edits are unsynchronized like on vanilla
+            }
+            LOCK = lock;
+            UNLOCK = unlock;
+        }
+
+        static void lock(UUID uuid) {
+            invoke(LOCK, uuid);
+        }
+
+        static void unlock(UUID uuid) {
+            invoke(UNLOCK, uuid);
+        }
+
+        private static void invoke(@Nullable Method method, UUID uuid) {
+            if (method == null) {
+                return;
+            }
+            try {
+                method.invoke(null, uuid);
+            } catch (ReflectiveOperationException e) {
+                LogManager.getLogger().warn("Utilities-OG player data lock failed for {}", uuid, e);
+            }
+        }
+    }
+
+    // A storage with saveCompoundTag(UUID, CompoundTag) keeps profiles in a database (TrueOG Purpur); its getPlayerData(UUID) never touches the entity
+    private static @Nullable Method storageSave(@NotNull PlayerDataStorage storage) {
+        try {
+            return storage.getClass().getMethod("saveCompoundTag", UUID.class, CompoundTag.class);
+        } catch (NoSuchMethodException e) {
+            return null;
+        }
+    }
+
+    private static @Nullable CompoundTag readStoredTag(@NotNull PlayerDataStorage storage, @NotNull ServerPlayer player) throws ReflectiveOperationException {
+        if (storageSave(storage) != null) {
+            Method get = storage.getClass().getMethod("getPlayerData", UUID.class);
+            return (CompoundTag) get.invoke(storage, player.getUUID());
+        }
+        // CraftBukkit's file read, which does not apply the data to the entity
+        Method getPlayerData = storage.getClass().getMethod("getPlayerData", String.class);
+        return (CompoundTag) getPlayerData.invoke(storage, player.getStringUUID());
+    }
+
+    // True when the storage took the profile itself (it logs a failed write); false means the caller keeps the file layout
+    private static boolean saveThroughStorageApi(@NotNull PlayerDataStorage storage, @NotNull UUID uuid, @NotNull CompoundTag playerData) throws ReflectiveOperationException {
+        Method save = storageSave(storage);
+        if (save == null) {
+            return false;
+        }
+        save.invoke(storage, uuid, playerData);
+        return true;
+    }
+
+    @Contract("null -> new")
+    private @NotNull CompoundTag getWritableTag(@Nullable CompoundTag oldData) {
+        if (oldData == null) {
+            return new CompoundTag();
+        }
+
+        // Copy old data. This is a deep clone, so operating on it should be safe.
+        oldData = oldData.copy();
+
+        // Remove vanilla/server data that is not written every time.
+        oldData.getAllKeys().removeIf(key -> RESET_TAGS.contains(key) || key.startsWith("Bukkit"));
+
+        return oldData;
+    }
+
+    private void revertSpecialValues(@NotNull CompoundTag newData, @NotNull CompoundTag oldData) {
+        // Revert automatic updates to play timestamps.
+        copyValue(oldData, newData, "bukkit", "lastPlayed", NumericTag.class);
+        copyValue(oldData, newData, "Paper", "LastSeen", NumericTag.class);
+        copyValue(oldData, newData, "Paper", "LastLogin", NumericTag.class);
+        // The persistent data container was captured when the inventory was opened; other plugins (MyWorlds nests its
+        // per-world profiles there) may have changed the stored one since, and this edit never touches it
+        Tag storedValues = oldData.get("BukkitValues");
+        if (storedValues != null) {
+            newData.put("BukkitValues", storedValues.copy());
+        } else {
+            newData.remove("BukkitValues");
+        }
+    }
+
+    private <T extends Tag> void copyValue(
+        @NotNull CompoundTag source,
+        @NotNull CompoundTag target,
+        @NotNull String container,
+        @NotNull String key,
+        @NotNull Class<T> tagType) {
+        CompoundTag oldContainer = getTag(source, container, CompoundTag.class);
+        CompoundTag newContainer = getTag(target, container, CompoundTag.class);
+
+        // New container being null means the server implementation doesn't store this data.
+        if (newContainer == null) {
+            return;
+        }
+
+        // If old tag exists, copy it to new location, removing otherwise.
+        setTag(newContainer, key, getTag(oldContainer, key, tagType));
+    }
+
+    private <T extends Tag> @Nullable T getTag(
+        @Nullable CompoundTag container,
+        @NotNull String key,
+        @NotNull Class<T> dataType) {
+        if (container == null) {
+            return null;
+        }
+        Tag value = container.get(key);
+        if (value == null || !dataType.isAssignableFrom(value.getClass())) {
+            return null;
+        }
+        return dataType.cast(value);
+    }
+
+    private <T extends Tag> void setTag(
+        @NotNull CompoundTag container,
+        @NotNull String key,
+        @Nullable T data) {
+        if (data == null) {
+            container.remove(key);
+        } else {
+            container.put(key, data);
+        }
+    }
+
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -14,37 +14,41 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-package com.lishid.openinv.internal.v1_17_R1;
+package com.lishid.openinv.internal.v1_19_R3;

 import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.internal.IPlayerDataManager;
 import com.lishid.openinv.internal.ISpecialInventory;
 import com.lishid.openinv.internal.OpenInventoryView;
 import com.mojang.authlib.GameProfile;
-import java.lang.reflect.Field;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import net.minecraft.network.chat.ChatComponentText;
-import net.minecraft.network.protocol.game.PacketPlayOutOpenWindow;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.EntityPlayer;
-import net.minecraft.server.level.WorldServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.Entity;
-import net.minecraft.world.inventory.Container;
-import net.minecraft.world.inventory.Containers;
-import net.minecraft.world.level.World;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.Vec3;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.Server;
-import org.bukkit.craftbukkit.v1_17_R1.CraftServer;
-import org.bukkit.craftbukkit.v1_17_R1.entity.CraftPlayer;
-import org.bukkit.craftbukkit.v1_17_R1.event.CraftEventFactory;
-import org.bukkit.craftbukkit.v1_17_R1.inventory.CraftContainer;
+import org.bukkit.craftbukkit.v1_19_R3.CraftServer;
+import org.bukkit.craftbukkit.v1_19_R3.CraftWorld;
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftPlayer;
+import org.bukkit.craftbukkit.v1_19_R3.event.CraftEventFactory;
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftContainer;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.InventoryView;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

+import java.lang.reflect.Field;
+import java.util.logging.Logger;
+
 public class PlayerDataManager implements IPlayerDataManager {

    private @Nullable Field bukkitEntity;
@@ -55,21 +59,21 @@ public class PlayerDataManager implements IPlayerDataManager {
        } catch (NoSuchFieldException e) {
            Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
            logger.warning("Unable to obtain field to inject custom save process - players' mounts may be deleted when loaded.");
-            logger.log(Level.WARNING, e.getMessage(), e);
+            logger.log(java.util.logging.Level.WARNING, e.getMessage(), e);
            bukkitEntity = null;
        }
    }

-    public static @NotNull EntityPlayer getHandle(final Player player) {
+    public static @NotNull ServerPlayer getHandle(final Player player) {
        if (player instanceof CraftPlayer) {
            return ((CraftPlayer) player).getHandle();
        }

        Server server = player.getServer();
-        EntityPlayer nmsPlayer = null;
+        ServerPlayer nmsPlayer = null;

        if (server instanceof CraftServer) {
-            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getName());
+            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getUniqueId());
        }

        if (nmsPlayer == null) {
@@ -88,17 +92,21 @@ public class PlayerDataManager implements IPlayerDataManager {
        }

        // Create a profile and entity to load the player data
-        // See net.minecraft.server.PlayerList#attemptLogin
+        // See net.minecraft.server.players.PlayerList#canPlayerLogin
+        // and net.minecraft.server.network.ServerLoginPacketListenerImpl#handleHello
        GameProfile profile = new GameProfile(offline.getUniqueId(),
                offline.getName() != null ? offline.getName() : offline.getUniqueId().toString());
        MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
-        WorldServer worldServer = server.getWorldServer(World.f);
+        ServerLevel worldServer = server.getLevel(Level.OVERWORLD);

        if (worldServer == null) {
            return null;
        }

-        EntityPlayer entity = new EntityPlayer(server, worldServer, profile);
+        ServerPlayer entity = new ServerPlayer(server, worldServer, profile);
+
+        // Stop listening for advancement progression - if this is not cleaned up, loading causes a memory leak.
+        entity.getAdvancements().stopListening();

        try {
            injectPlayer(entity);
@@ -106,31 +114,66 @@ public class PlayerDataManager implements IPlayerDataManager {
            e.printStackTrace();
        }

-        // Get the bukkit entity
-        Player target = entity.getBukkitEntity();
-        if (target != null) {
-            // Load data
-            target.loadData();
+        // Load data. This also reads basic data into the player.
+        // See CraftPlayer#loadData
+        // The server's own storage, not PlayerList.playerIo: a world manager may hook that field and answer with a per-world profile, and an offline edit always means the main profile.
+        CompoundTag loadedData = server.playerDataStorage.load(entity);
+
+        if (loadedData == null) {
+            // Exceptions with loading are logged by Mojang.
+            return null;
        }
-        // Return the entity
-        return target;
+        // A stored tag without a position is no profile, only data other plugins keep for a player who never joined
+        // (a MyWorlds inventory group, for example); editing it would turn it into a profile placed at 0,0,0.
+        if (!loadedData.contains("Pos", Tag.TAG_LIST)) {
+            return null;
+        }
+
+        // Also read "extra" data.
+        entity.readAdditionalSaveData(loadedData);
+        entity.loadGameTypes(loadedData);
+
+        if (entity.level == null) {
+            // Paper: Move player to spawn
+            // SPIGOT-7340: Cannot call ServerPlayer#spawnIn with a null world
+            ServerLevel level = null;
+            Vec3 position = null;
+            if (entity.getRespawnDimension() != null) {
+                level = entity.server.getLevel(entity.getRespawnDimension());
+                if (level != null && entity.getRespawnPosition() != null) {
+                    position = net.minecraft.world.entity.player.Player.findRespawnPositionAndUseSpawnBlock(level, entity.getRespawnPosition(), entity.getRespawnAngle(), false, false).orElse(null);
+                }
+            }
+            if (level == null || position == null) {
+                level = ((CraftWorld) server.server.getWorlds().get(0)).getHandle();
+                position = Vec3.atCenterOf(level.getSharedSpawnPos());
+            }
+            entity.level = level;
+            entity.setPos(position);
+        }
+
+        // Return the Bukkit entity.
+        return entity.getBukkitEntity();
    }

-    void injectPlayer(EntityPlayer player) throws IllegalAccessException {
+    void injectPlayer(ServerPlayer player) throws IllegalAccessException {
        if (bukkitEntity == null) {
            return;
        }

        bukkitEntity.setAccessible(true);

-        bukkitEntity.set(player, new OpenPlayer(player.c.server, player));
+        bukkitEntity.set(player, new OpenPlayer(player.server.server, player));
    }

    @NotNull
    @Override
    public Player inject(@NotNull Player player) {
        try {
-            EntityPlayer nmsPlayer = getHandle(player);
+            ServerPlayer nmsPlayer = getHandle(player);
+            if (nmsPlayer.getBukkitEntity() instanceof OpenPlayer openPlayer) {
+                return openPlayer;
+            }
            injectPlayer(nmsPlayer);
            return nmsPlayer.getBukkitEntity();
        } catch (IllegalAccessException e) {
@@ -143,9 +186,9 @@ public class PlayerDataManager implements IPlayerDataManager {
    @Override
    public InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {

-        EntityPlayer nmsPlayer = getHandle(player);
+        ServerPlayer nmsPlayer = getHandle(player);

-        if (nmsPlayer.b == null) {
+        if (nmsPlayer.connection == null) {
            return null;
        }

@@ -155,23 +198,23 @@ public class PlayerDataManager implements IPlayerDataManager {
            return player.openInventory(inventory.getBukkitInventory());
        }

-        Container container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
+        AbstractContainerMenu container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
            @Override
-            public Containers<?> getType() {
+            public MenuType<?> getType() {
                return getContainers(inventory.getBukkitInventory().getSize());
            }
        };

-        container.setTitle(new ChatComponentText(view.getTitle()));
+        container.setTitle(Component.literal(view.getTitle()));
        container = CraftEventFactory.callInventoryOpenEvent(nmsPlayer, container);

        if (container == null) {
            return null;
        }

-        nmsPlayer.b.sendPacket(new PacketPlayOutOpenWindow(container.j, container.getType(),
-                new ChatComponentText(container.getBukkitView().getTitle())));
-        nmsPlayer.bV = container;
+        nmsPlayer.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(),
+                Component.literal(container.getBukkitView().getTitle())));
+        nmsPlayer.containerMenu = container;
        nmsPlayer.initMenu(container);

        return container.getBukkitView();
@@ -188,15 +231,15 @@ public class PlayerDataManager implements IPlayerDataManager {
        }
    }

-    static @NotNull Containers<?> getContainers(int inventorySize) {
+    static @NotNull MenuType<?> getContainers(int inventorySize) {

        return switch (inventorySize) {
-            case 9 -> Containers.a;
-            case 18 -> Containers.b;
-            case 36 -> Containers.d; // PLAYER
-            case 41, 45 -> Containers.e;
-            case 54 -> Containers.f;
-            default -> Containers.c; // 9x3
+            case 9 -> MenuType.GENERIC_9x1;
+            case 18 -> MenuType.GENERIC_9x2;
+            case 36 -> MenuType.GENERIC_9x4; // PLAYER
+            case 41, 45 -> MenuType.GENERIC_9x5;
+            case 54 -> MenuType.GENERIC_9x6;
+            default -> MenuType.GENERIC_9x3; // Default 27-slot inventory
        };
    }

@@ -0,0 +1,350 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_19_R3;
+
+import com.lishid.openinv.internal.ISpecialEnderChest;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.ContainerListener;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.player.StackedContents;
+import net.minecraft.world.inventory.PlayerEnderChestContainer;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.entity.EnderChestBlockEntity;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftInventory;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpecialEnderChest {
+
+    private final CraftInventory inventory;
+    private ServerPlayer owner;
+    private NonNullList<ItemStack> items;
+    private boolean playerOnline;
+
+    public SpecialEnderChest(final org.bukkit.entity.Player player, final Boolean online) {
+        super(PlayerDataManager.getHandle(player));
+        this.inventory = new CraftInventory(this);
+        this.owner = PlayerDataManager.getHandle(player);
+        this.playerOnline = online;
+        this.items = this.owner.getEnderChestInventory().items;
+    }
+
+    @Override
+    public @NotNull CraftInventory getBukkitInventory() {
+        return inventory;
+    }
+
+    @Override
+    public void setPlayerOffline() {
+        this.playerOnline = false;
+    }
+
+    @Override
+    public void setPlayerOnline(@NotNull final org.bukkit.entity.Player player) {
+        if (this.playerOnline) {
+            return;
+        }
+
+        ServerPlayer offlinePlayer = this.owner;
+        ServerPlayer onlinePlayer = PlayerDataManager.getHandle(player);
+
+        // Set owner to new player.
+        this.owner = onlinePlayer;
+
+        // Set player's ender chest contents to our modified contents.
+        PlayerEnderChestContainer onlineEnderChest = onlinePlayer.getEnderChestInventory();
+        for (int i = 0; i < onlineEnderChest.getContainerSize(); ++i) {
+            onlineEnderChest.setItem(i, this.items.get(i));
+        }
+
+        // Set our item array to the new inventory's array.
+        this.items = onlineEnderChest.items;
+
+        // Add viewers to new inventory.
+        onlineEnderChest.transaction.addAll(offlinePlayer.getEnderChestInventory().transaction);
+
+        this.playerOnline = true;
+    }
+
+    @Override
+    public @NotNull org.bukkit.entity.Player getPlayer() {
+        return owner.getBukkitEntity();
+    }
+
+    @Override
+    public void setChanged() {
+        this.owner.getEnderChestInventory().setChanged();
+    }
+
+    @Override
+    public List<ItemStack> getContents() {
+        return this.items;
+    }
+
+    @Override
+    public void onOpen(CraftHumanEntity who) {
+        this.owner.getEnderChestInventory().onOpen(who);
+    }
+
+    @Override
+    public void onClose(CraftHumanEntity who) {
+        this.owner.getEnderChestInventory().onClose(who);
+    }
+
+    @Override
+    public List<HumanEntity> getViewers() {
+        return this.owner.getEnderChestInventory().getViewers();
+    }
+
+    @Override
+    public boolean stillValid(Player player) {
+        return true;
+    }
+
+    @Override
+    public void setActiveChest(EnderChestBlockEntity enderChest) {
+        this.owner.getEnderChestInventory().setActiveChest(enderChest);
+    }
+
+    @Override
+    public boolean isActiveChest(EnderChestBlockEntity enderChest) {
+        return this.owner.getEnderChestInventory().isActiveChest(enderChest);
+    }
+
+    @Override
+    public int getMaxStackSize() {
+        return this.owner.getEnderChestInventory().getMaxStackSize();
+    }
+
+    @Override
+    public void setMaxStackSize(int i) {
+        this.owner.getEnderChestInventory().setMaxStackSize(i);
+    }
+
+    @Override
+    public InventoryHolder getOwner() {
+        return this.owner.getEnderChestInventory().getOwner();
+    }
+
+    @Override
+    public @Nullable Location getLocation() {
+        return null;
+    }
+
+    @Override
+    public void addListener(ContainerListener listener) {
+        this.owner.getEnderChestInventory().addListener(listener);
+    }
+
+    @Override
+    public void removeListener(ContainerListener listener) {
+        this.owner.getEnderChestInventory().removeListener(listener);
+    }
+
+    @Override
+    public ItemStack getItem(int i) {
+        return i >= 0 && i < this.items.size() ? this.items.get(i) : ItemStack.EMPTY;
+    }
+
+    @Override
+    public ItemStack removeItem(int i, int j) {
+        ItemStack itemstack = ContainerHelper.removeItem(this.items, i, j);
+        if (!itemstack.isEmpty()) {
+            this.setChanged();
+        }
+
+        return itemstack;
+    }
+
+    @Override
+    public ItemStack addItem(ItemStack itemstack) {
+        ItemStack localItem = itemstack.copy();
+        this.moveItemToOccupiedSlotsWithSameType(localItem);
+        if (localItem.isEmpty()) {
+            return ItemStack.EMPTY;
+        } else {
+            this.moveItemToEmptySlots(localItem);
+            return localItem.isEmpty() ? ItemStack.EMPTY : localItem;
+        }
+    }
+
+    @Override
+    public boolean canAddItem(ItemStack itemstack) {
+        for (ItemStack itemstack1 : this.items) {
+            if (itemstack1.isEmpty() || ItemStack.isSameItemSameTags(itemstack1, itemstack) && itemstack1.getCount() < itemstack1.getMaxStackSize()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private void moveItemToEmptySlots(ItemStack itemstack) {
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            ItemStack localItem = this.getItem(i);
+            if (localItem.isEmpty()) {
+                this.setItem(i, itemstack.copy());
+                itemstack.setCount(0);
+                return;
+            }
+        }
+    }
+
+    private void moveItemToOccupiedSlotsWithSameType(ItemStack itemstack) {
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            ItemStack localItem = this.getItem(i);
+            if (ItemStack.isSameItemSameTags(localItem, itemstack)) {
+                this.moveItemsBetweenStacks(itemstack, localItem);
+                if (itemstack.isEmpty()) {
+                    return;
+                }
+            }
+        }
+    }
+
+    private void moveItemsBetweenStacks(ItemStack itemstack, ItemStack itemstack1) {
+        int i = Math.min(this.getMaxStackSize(), itemstack1.getMaxStackSize());
+        int j = Math.min(itemstack.getCount(), i - itemstack1.getCount());
+        if (j > 0) {
+            itemstack1.grow(j);
+            itemstack.shrink(j);
+            this.setChanged();
+        }
+    }
+
+    @Override
+    public ItemStack removeItemNoUpdate(int i) {
+        ItemStack itemstack = this.items.get(i);
+        if (itemstack.isEmpty()) {
+            return ItemStack.EMPTY;
+        } else {
+            this.items.set(i, ItemStack.EMPTY);
+            return itemstack;
+        }
+    }
+
+    @Override
+    public void setItem(int i, ItemStack itemstack) {
+        this.items.set(i, itemstack);
+        if (!itemstack.isEmpty() && itemstack.getCount() > this.getMaxStackSize()) {
+            itemstack.setCount(this.getMaxStackSize());
+        }
+
+        this.setChanged();
+    }
+
+    @Override
+    public int getContainerSize() {
+        return this.owner.getEnderChestInventory().getContainerSize();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.items.stream().allMatch(ItemStack::isEmpty);
+    }
+
+    @Override
+    public void startOpen(Player player) {
+    }
+
+    @Override
+    public void stopOpen(Player player) {
+    }
+
+    @Override
+    public boolean canPlaceItem(int i, ItemStack itemstack) {
+        return true;
+    }
+
+    @Override
+    public void clearContent() {
+        this.items.clear();
+        this.setChanged();
+    }
+
+    @Override
+    public void fillStackedContents(StackedContents stackedContents) {
+        for (ItemStack itemstack : this.items) {
+            stackedContents.accountStack(itemstack);
+        }
+
+    }
+
+    @Override
+    public List<ItemStack> removeAllItems() {
+        List<ItemStack> list = this.items.stream().filter(Predicate.not(ItemStack::isEmpty)).collect(Collectors.toList());
+        this.clearContent();
+        return list;
+    }
+
+    @Override
+    public ItemStack removeItemType(Item item, int i) {
+        ItemStack itemstack = new ItemStack(item, 0);
+
+        for(int j = this.getContainerSize() - 1; j >= 0; --j) {
+            ItemStack localItem = this.getItem(j);
+            if (localItem.getItem().equals(item)) {
+                int k = i - itemstack.getCount();
+                ItemStack splitItem = localItem.split(k);
+                itemstack.grow(splitItem.getCount());
+                if (itemstack.getCount() == i) {
+                    break;
+                }
+            }
+        }
+
+        if (!itemstack.isEmpty()) {
+            this.setChanged();
+        }
+
+        return itemstack;
+    }
+
+    @Override
+    public String toString() {
+        return this.items.stream().filter((itemStack) -> !itemStack.isEmpty()).toList().toString();
+    }
+
+    @Override
+    public void fromTag(ListTag listTag) {
+        for (int i = 0; i < this.getContainerSize(); ++i) {
+            this.setItem(i, ItemStack.EMPTY);
+        }
+
+        for (int i = 0; i < listTag.size(); ++i) {
+            CompoundTag compoundTag = listTag.getCompound(i);
+            int j = compoundTag.getByte("Slot") & 255;
+            if (j < this.getContainerSize()) {
+                this.setItem(j, ItemStack.of(compoundTag));
+            }
+        }
+
+    }
+
+}
@@ -0,0 +1,806 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_19_R3;
+
+import com.google.common.collect.ImmutableList;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import net.minecraft.CrashReport;
+import net.minecraft.CrashReportCategory;
+import net.minecraft.ReportedException;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.tags.DamageTypeTags;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.Container;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.player.StackedContents;
+import net.minecraft.world.item.ArmorItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.state.BlockState;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftInventory;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class SpecialPlayerInventory extends Inventory implements ISpecialPlayerInventory {
+
+    private final CraftInventory inventory;
+    private boolean playerOnline;
+    private Player player;
+    private NonNullList<ItemStack> items;
+    private NonNullList<ItemStack> armor;
+    private NonNullList<ItemStack> offhand;
+    private List<NonNullList<ItemStack>> compartments;
+
+    public SpecialPlayerInventory(@NotNull org.bukkit.entity.Player bukkitPlayer, @NotNull Boolean online) {
+        super(PlayerDataManager.getHandle(bukkitPlayer));
+        this.inventory = new CraftInventory(this);
+        this.playerOnline = online;
+        this.player = super.player;
+        this.selected = player.getInventory().selected;
+        this.items = this.player.getInventory().items;
+        this.armor = this.player.getInventory().armor;
+        this.offhand = this.player.getInventory().offhand;
+        this.compartments = ImmutableList.of(this.items, this.armor, this.offhand);
+    }
+
+    @Override
+    public void setPlayerOnline(@NotNull org.bukkit.entity.Player player) {
+        if (this.playerOnline) {
+            return;
+        }
+
+        Player offlinePlayer = this.player;
+        Player onlinePlayer = PlayerDataManager.getHandle(player);
+        onlinePlayer.getInventory().transaction.addAll(this.transaction);
+
+        // Set owner to new player.
+        this.player = onlinePlayer;
+
+        // Set player's inventory contents to our modified contents.
+        Inventory onlineInventory = onlinePlayer.getInventory();
+        for (int i = 0; i < getContainerSize(); ++i) {
+            onlineInventory.setItem(i, getRawItem(i));
+        }
+        onlineInventory.selected = this.selected;
+
+        // Set our item arrays to the new inventory's arrays.
+        this.items = onlineInventory.items;
+        this.armor = onlineInventory.armor;
+        this.offhand = onlineInventory.offhand;
+        this.compartments = ImmutableList.of(this.items, this.armor, this.offhand);
+
+        // Add existing viewers to new viewer list.
+        Inventory offlineInventory = offlinePlayer.getInventory();
+        // Remove self from listing - player is always a viewer of their own inventory, prevent duplicates.
+        offlineInventory.transaction.remove(offlinePlayer.getBukkitEntity());
+        onlineInventory.transaction.addAll(offlineInventory.transaction);
+
+        this.playerOnline = true;
+    }
+
+    @Override
+    public @NotNull CraftInventory getBukkitInventory() {
+        return this.inventory;
+    }
+
+    @Override
+    public void setPlayerOffline() {
+        this.playerOnline = false;
+    }
+
+    @Override
+    public @NotNull HumanEntity getPlayer() {
+        return this.player.getBukkitEntity();
+    }
+
+    private @NotNull ItemStack getRawItem(int i) {
+        if (i < 0) {
+            return ItemStack.EMPTY;
+        }
+
+        NonNullList<ItemStack> list;
+        for (Iterator<NonNullList<ItemStack>> iterator = this.compartments.iterator(); iterator.hasNext(); i -= list.size()) {
+            list = iterator.next();
+            if (i < list.size()) {
+                return list.get(i);
+            }
+        }
+
+        return ItemStack.EMPTY;
+    }
+
+    private void setRawItem(int i, @NotNull ItemStack itemStack) {
+        if (i < 0) {
+            return;
+        }
+
+        NonNullList<ItemStack> list;
+        for (Iterator<NonNullList<ItemStack>> iterator = this.compartments.iterator(); iterator.hasNext(); i -= list.size()) {
+            list = iterator.next();
+            if (i < list.size()) {
+                list.set(i, itemStack);
+            }
+        }
+    }
+
+    private record IndexedCompartment(@Nullable NonNullList<ItemStack> compartment, int index) {}
+
+    private @NotNull SpecialPlayerInventory.IndexedCompartment getIndexedContent(int index) {
+        if (index < items.size()) {
+            return new IndexedCompartment(items, getReversedItemSlotNum(index));
+        }
+
+        index -= items.size();
+
+        if (index < armor.size()) {
+            return new IndexedCompartment(armor, getReversedArmorSlotNum(index));
+        }
+
+        index -= armor.size();
+
+        if (index < offhand.size()) {
+            return new IndexedCompartment(offhand, index);
+        }
+
+        index -= offhand.size();
+
+        return new IndexedCompartment(null, index);
+    }
+
+    private int getReversedArmorSlotNum(final int i) {
+        if (i == 0) {
+            return 3;
+        }
+        if (i == 1) {
+            return 2;
+        }
+        if (i == 2) {
+            return 1;
+        }
+        if (i == 3) {
+            return 0;
+        }
+        return i;
+    }
+
+    private int getReversedItemSlotNum(final int i) {
+        if (i >= 27) {
+            return i - 27;
+        }
+        return i + 9;
+    }
+
+    private boolean contains(Predicate<ItemStack> predicate) {
+        return this.compartments.stream().flatMap(NonNullList::stream).anyMatch(predicate);
+    }
+
+    @Override
+    public List<ItemStack> getArmorContents() {
+        return this.armor;
+    }
+
+    @Override
+    public void onOpen(CraftHumanEntity who) {
+        this.player.getInventory().onOpen(who);
+    }
+
+    @Override
+    public void onClose(CraftHumanEntity who) {
+        this.player.getInventory().onClose(who);
+    }
+
+    @Override
+    public List<HumanEntity> getViewers() {
+        return this.player.getInventory().getViewers();
+    }
+
+    @Override
+    public InventoryHolder getOwner() {
+        return this.player.getBukkitEntity();
+    }
+
+    @Override
+    public int getMaxStackSize() {
+        return this.player.getInventory().getMaxStackSize();
+    }
+
+    @Override
+    public void setMaxStackSize(int size) {
+        this.player.getInventory().setMaxStackSize(size);
+    }
+
+    @Override
+    public Location getLocation() {
+        return this.player.getBukkitEntity().getLocation();
+    }
+
+    @Override
+    public boolean hasCustomName() {
+        return false;
+    }
+
+    @Override
+    public List<ItemStack> getContents() {
+        return this.compartments.stream().flatMap(Collection::stream).collect(Collectors.toList());
+    }
+
+    @Override
+    public ItemStack getSelected() {
+        return isHotbarSlot(this.selected) ? this.items.get(this.selected) : ItemStack.EMPTY;
+    }
+
+    private boolean hasRemainingSpaceForItem(ItemStack itemstack, ItemStack itemstack1) {
+        return !itemstack.isEmpty() && ItemStack.isSameItemSameTags(itemstack, itemstack1) && itemstack.isStackable() && itemstack.getCount() < itemstack.getMaxStackSize() && itemstack.getCount() < this.getMaxStackSize();
+    }
+
+    @Override
+    public int canHold(ItemStack itemstack) {
+        int remains = itemstack.getCount();
+
+        for (int i = 0; i < this.items.size(); ++i) {
+            ItemStack itemstack1 = this.getRawItem(i);
+            if (itemstack1.isEmpty()) {
+                return itemstack.getCount();
+            }
+
+            if (this.hasRemainingSpaceForItem(itemstack1, itemstack)) {
+                remains -= (itemstack1.getMaxStackSize() < this.getMaxStackSize() ? itemstack1.getMaxStackSize() : this.getMaxStackSize()) - itemstack1.getCount();
+            }
+
+            if (remains <= 0) {
+                return itemstack.getCount();
+            }
+        }
+
+        ItemStack offhandItemStack = this.getRawItem(this.items.size() + this.armor.size());
+        if (this.hasRemainingSpaceForItem(offhandItemStack, itemstack)) {
+            remains -= (offhandItemStack.getMaxStackSize() < this.getMaxStackSize() ? offhandItemStack.getMaxStackSize() : this.getMaxStackSize()) - offhandItemStack.getCount();
+        }
+
+        return remains <= 0 ? itemstack.getCount() : itemstack.getCount() - remains;
+    }
+
+    @Override
+    public int getFreeSlot() {
+        for(int i = 0; i < this.items.size(); ++i) {
+            if (this.items.get(i).isEmpty()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public void setPickedItem(ItemStack itemstack) {
+        int i = this.findSlotMatchingItem(itemstack);
+        if (isHotbarSlot(i)) {
+            this.selected = i;
+        } else if (i == -1) {
+            this.selected = this.getSuitableHotbarSlot();
+            if (!this.items.get(this.selected).isEmpty()) {
+                int j = this.getFreeSlot();
+                if (j != -1) {
+                    this.items.set(j, this.items.get(this.selected));
+                }
+            }
+
+            this.items.set(this.selected, itemstack);
+        } else {
+            this.pickSlot(i);
+        }
+
+    }
+
+    @Override
+    public void pickSlot(int i) {
+        this.selected = this.getSuitableHotbarSlot();
+        ItemStack itemstack = this.items.get(this.selected);
+        this.items.set(this.selected, this.items.get(i));
+        this.items.set(i, itemstack);
+    }
+
+    @Override
+    public int findSlotMatchingItem(ItemStack itemstack) {
+        for(int i = 0; i < this.items.size(); ++i) {
+            if (!this.items.get(i).isEmpty() && ItemStack.isSameItemSameTags(itemstack, this.items.get(i))) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public int findSlotMatchingUnusedItem(ItemStack itemStack) {
+        for(int i = 0; i < this.items.size(); ++i) {
+            ItemStack localItem = this.items.get(i);
+            if (!this.items.get(i).isEmpty() && ItemStack.isSameItemSameTags(itemStack, this.items.get(i)) && !this.items.get(i).isDamaged() && !localItem.isEnchanted() && !localItem.hasCustomHoverName()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public int getSuitableHotbarSlot() {
+        int i;
+        int j;
+        for(j = 0; j < 9; ++j) {
+            i = (this.selected + j) % 9;
+            if (this.items.get(i).isEmpty()) {
+                return i;
+            }
+        }
+
+        for(j = 0; j < 9; ++j) {
+            i = (this.selected + j) % 9;
+            if (!this.items.get(i).isEnchanted()) {
+                return i;
+            }
+        }
+
+        return this.selected;
+    }
+
+    @Override
+    public void swapPaint(double d0) {
+        if (d0 > 0.0D) {
+            d0 = 1.0D;
+        }
+
+        if (d0 < 0.0D) {
+            d0 = -1.0D;
+        }
+
+        this.selected = (int) (this.selected - d0);
+
+        while (this.selected < 0) {
+            this.selected += 9;
+        }
+
+        while(this.selected >= 9) {
+            this.selected -= 9;
+        }
+    }
+
+    @Override
+    public int clearOrCountMatchingItems(Predicate<ItemStack> predicate, int i, Container container) {
+        byte b0 = 0;
+        boolean flag = i == 0;
+        int j = b0 + ContainerHelper.clearOrCountMatchingItems(this, predicate, i - b0, flag);
+        j += ContainerHelper.clearOrCountMatchingItems(container, predicate, i - j, flag);
+        ItemStack itemstack = this.player.containerMenu.getCarried();
+        j += ContainerHelper.clearOrCountMatchingItems(itemstack, predicate, i - j, flag);
+        if (itemstack.isEmpty()) {
+            this.player.containerMenu.setCarried(ItemStack.EMPTY);
+        }
+
+        return j;
+    }
+
+    private int addResource(ItemStack itemstack) {
+        int i = this.getSlotWithRemainingSpace(itemstack);
+        if (i == -1) {
+            i = this.getFreeSlot();
+        }
+
+        return i == -1 ? itemstack.getCount() : this.addResource(i, itemstack);
+    }
+
+    private int addResource(int i, ItemStack itemstack) {
+        Item item = itemstack.getItem();
+        int j = itemstack.getCount();
+        ItemStack localItemStack = this.getRawItem(i);
+        if (localItemStack.isEmpty()) {
+            localItemStack = new ItemStack(item, 0);
+            if (itemstack.hasTag()) {
+                // hasTag ensures tag not null
+                //noinspection ConstantConditions
+                localItemStack.setTag(itemstack.getTag().copy());
+            }
+
+            this.setRawItem(i, localItemStack);
+        }
+
+        int k = Math.min(j, localItemStack.getMaxStackSize() - localItemStack.getCount());
+
+        if (k > this.getMaxStackSize() - localItemStack.getCount()) {
+            k = this.getMaxStackSize() - localItemStack.getCount();
+        }
+
+        if (k != 0) {
+            j -= k;
+            localItemStack.grow(k);
+            localItemStack.setPopTime(5);
+        }
+
+        return j;
+    }
+
+    @Override
+    public int getSlotWithRemainingSpace(ItemStack itemstack) {
+        if (this.hasRemainingSpaceForItem(this.getRawItem(this.selected), itemstack)) {
+            return this.selected;
+        } else if (this.hasRemainingSpaceForItem(this.getRawItem(40), itemstack)) {
+            return 40;
+        } else {
+            for(int i = 0; i < this.items.size(); ++i) {
+                if (this.hasRemainingSpaceForItem(this.items.get(i), itemstack)) {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+    }
+
+    @Override
+    public void tick() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                if (!compartment.get(i).isEmpty()) {
+                    compartment.get(i).inventoryTick(this.player.level, this.player, i, this.selected == i);
+                }
+            }
+        }
+
+    }
+
+    @Override
+    public boolean add(ItemStack itemStack) {
+        return this.add(-1, itemStack);
+    }
+
+    @Override
+    public boolean add(int i, ItemStack itemStack) {
+        if (itemStack.isEmpty()) {
+            return false;
+        } else {
+            try {
+                if (itemStack.isDamaged()) {
+                    if (i == -1) {
+                        i = this.getFreeSlot();
+                    }
+
+                    if (i >= 0) {
+                        this.items.set(i, itemStack.copy());
+                        this.items.get(i).setPopTime(5);
+                        itemStack.setCount(0);
+                        return true;
+                    } else if (this.player.getAbilities().instabuild) {
+                        itemStack.setCount(0);
+                        return true;
+                    } else {
+                        return false;
+                    }
+                } else {
+                    int j;
+                    do {
+                        j = itemStack.getCount();
+                        if (i == -1) {
+                            itemStack.setCount(this.addResource(itemStack));
+                        } else {
+                            itemStack.setCount(this.addResource(i, itemStack));
+                        }
+                    } while(!itemStack.isEmpty() && itemStack.getCount() < j);
+
+                    if (itemStack.getCount() == j && this.player.getAbilities().instabuild) {
+                        itemStack.setCount(0);
+                        return true;
+                    } else {
+                        return itemStack.getCount() < j;
+                    }
+                }
+            } catch (Throwable var6) {
+                CrashReport crashReport = CrashReport.forThrowable(var6, "Adding item to inventory");
+                CrashReportCategory crashReportCategory = crashReport.addCategory("Item being added");
+                crashReportCategory.setDetail("Item ID", Item.getId(itemStack.getItem()));
+                crashReportCategory.setDetail("Item data", itemStack.getDamageValue());
+                crashReportCategory.setDetail("Item name", () -> itemStack.getHoverName().getString());
+                throw new ReportedException(crashReport);
+            }
+        }
+    }
+
+    @Override
+    public void placeItemBackInInventory(ItemStack itemStack) {
+        this.placeItemBackInInventory(itemStack, true);
+    }
+
+    @Override
+    public void placeItemBackInInventory(ItemStack itemStack, boolean flag) {
+        while(true) {
+            if (!itemStack.isEmpty()) {
+                int i = this.getSlotWithRemainingSpace(itemStack);
+                if (i == -1) {
+                    i = this.getFreeSlot();
+                }
+
+                if (i != -1) {
+                    int j = itemStack.getMaxStackSize() - this.getRawItem(i).getCount();
+                    if (this.add(i, itemStack.split(j)) && flag && this.player instanceof ServerPlayer) {
+                        ((ServerPlayer)this.player).connection.send(new ClientboundContainerSetSlotPacket(-2, 0, i, this.getRawItem(i)));
+                    }
+                    continue;
+                }
+
+                this.player.drop(itemStack, false);
+            }
+
+            return;
+        }
+    }
+
+    @Override
+    public ItemStack removeItem(int rawIndex, final int j) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null
+                || indexedCompartment.compartment().get(indexedCompartment.index()).isEmpty()) {
+            return ItemStack.EMPTY;
+        }
+
+        return ContainerHelper.removeItem(indexedCompartment.compartment(), indexedCompartment.index(), j);
+    }
+
+    @Override
+    public void removeItem(ItemStack itemStack) {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                if (compartment.get(i) == itemStack) {
+                    compartment.set(i, ItemStack.EMPTY);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public ItemStack removeItemNoUpdate(int rawIndex) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            return ItemStack.EMPTY;
+        }
+
+        ItemStack removed = indexedCompartment.compartment().set(indexedCompartment.index(), ItemStack.EMPTY);
+
+        if (removed.isEmpty()) {
+            return ItemStack.EMPTY;
+        }
+
+        return removed;
+    }
+
+    @Override
+    public void setItem(int rawIndex, final ItemStack itemStack) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            this.player.drop(itemStack, true);
+            return;
+        }
+
+        indexedCompartment.compartment().set(indexedCompartment.index(), itemStack);
+    }
+
+    @Override
+    public float getDestroySpeed(BlockState blockState) {
+        return this.items.get(this.selected).getDestroySpeed(blockState);
+    }
+
+    @Override
+    public ListTag save(ListTag listTag) {
+        for (int i = 0; i < this.items.size(); ++i) {
+            if (!this.items.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)i);
+                this.items.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        for (int i = 0; i < this.armor.size(); ++i) {
+            if (!this.armor.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)(i + 100));
+                this.armor.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        for (int i = 0; i < this.offhand.size(); ++i) {
+            if (!this.offhand.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)(i + 150));
+                this.offhand.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        return listTag;
+    }
+
+    @Override
+    public void load(ListTag listTag) {
+        this.items.clear();
+        this.armor.clear();
+        this.offhand.clear();
+
+        for(int i = 0; i < listTag.size(); ++i) {
+            CompoundTag compoundTag = listTag.getCompound(i);
+            int j = compoundTag.getByte("Slot") & 255;
+            ItemStack itemstack = ItemStack.of(compoundTag);
+            if (!itemstack.isEmpty()) {
+                if (j < this.items.size()) {
+                    this.items.set(j, itemstack);
+                } else if (j >= 100 && j < this.armor.size() + 100) {
+                    this.armor.set(j - 100, itemstack);
+                } else if (j >= 150 && j < this.offhand.size() + 150) {
+                    this.offhand.set(j - 150, itemstack);
+                }
+            }
+        }
+
+    }
+
+    @Override
+    public int getContainerSize() {
+        return 45;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return !contains(itemStack -> !itemStack.isEmpty());
+    }
+
+    @Override
+    public ItemStack getItem(int rawIndex) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            return ItemStack.EMPTY;
+        }
+
+        return indexedCompartment.compartment().get(indexedCompartment.index());
+    }
+
+    @Override
+    public Component getName() {
+        return this.player.getName();
+    }
+
+    @Override
+    public ItemStack getArmor(int index) {
+        return this.armor.get(index);
+    }
+
+    @Override
+    public void hurtArmor(DamageSource damagesource, float damage, int[] armorIndices) {
+        if (damage > 0.0F) {
+            damage /= 4.0F;
+            if (damage < 1.0F) {
+                damage = 1.0F;
+            }
+
+            for (int index : armorIndices) {
+                ItemStack itemstack = this.armor.get(index);
+                if ((!damagesource.is(DamageTypeTags.IS_FIRE) || !itemstack.getItem().isFireResistant()) && itemstack.getItem() instanceof ArmorItem) {
+                    itemstack.hurtAndBreak((int) damage, this.player, localPlayer -> localPlayer.broadcastBreakEvent(EquipmentSlot.byTypeAndIndex(EquipmentSlot.Type.ARMOR, index)));
+                }
+            }
+        }
+    }
+
+    @Override
+    public void dropAll() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                ItemStack itemstack = compartment.get(i);
+                if (!itemstack.isEmpty()) {
+                    this.player.drop(itemstack, true, false);
+                    compartment.set(i, ItemStack.EMPTY);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void setChanged() {
+        super.setChanged();
+    }
+
+    @Override
+    public int getTimesChanged() {
+        return super.getTimesChanged();
+    }
+
+    @Override
+    public boolean stillValid(Player player) {
+        return true;
+    }
+
+    @Override
+    public boolean contains(ItemStack itemstack) {
+        return contains(itemStack -> itemStack.isEmpty() && itemStack.sameItem(itemstack));
+    }
+
+    @Override
+    public boolean contains(TagKey<Item> tagKey) {
+
+        return contains(itemStack -> !itemStack.isEmpty() && itemStack.is(tagKey));
+    }
+
+    @Override
+    public void replaceWith(Inventory inventory) {
+        Function<Integer, ItemStack> getter;
+
+        if (inventory instanceof SpecialPlayerInventory specialPlayerInventory) {
+            getter = specialPlayerInventory::getRawItem;
+        } else {
+            getter = inventory::getItem;
+        }
+
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            this.setRawItem(i, getter.apply(i));
+        }
+
+        this.selected = inventory.selected;
+    }
+
+    @Override
+    public void clearContent() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            compartment.clear();
+        }
+    }
+
+    @Override
+    public void fillStackedContents(StackedContents stackedContents) {
+        for (ItemStack itemstack : this.items) {
+            stackedContents.accountSimpleStack(itemstack);
+        }
+    }
+
+    @Override
+    public ItemStack removeFromSelected(boolean dropWholeStack) {
+        ItemStack itemstack = this.getSelected();
+        return itemstack.isEmpty() ? ItemStack.EMPTY : this.removeItem(this.selected, dropWholeStack ? itemstack.getCount() : 1);
+    }
+
+}
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R2;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IAnySilentContainer;
+import com.lishid.openinv.util.ReflectionHelper;
+import java.lang.reflect.Field;
+import java.util.logging.Logger;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.level.ServerPlayerGameMode;
+import net.minecraft.world.MenuProvider;
+import net.minecraft.world.SimpleMenuProvider;
+import net.minecraft.world.entity.monster.Shulker;
+import net.minecraft.world.inventory.ChestMenu;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.inventory.PlayerEnderChestContainer;
+import net.minecraft.world.level.GameType;
+import net.minecraft.world.level.block.BarrelBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.ShulkerBoxBlock;
+import net.minecraft.world.level.block.TrappedChestBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.EnderChestBlockEntity;
+import net.minecraft.world.level.block.entity.RandomizableContainerBlockEntity;
+import net.minecraft.world.level.block.entity.ShulkerBoxBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.AABB;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.Statistic;
+import org.bukkit.block.ShulkerBox;
+import org.bukkit.craftbukkit.v1_20_R2.CraftWorld;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class AnySilentContainer implements IAnySilentContainer {
+
+    private @Nullable Field serverPlayerGameModeGameType;
+
+    public AnySilentContainer() {
+        try {
+            try {
+                this.serverPlayerGameModeGameType = ServerPlayerGameMode.class.getDeclaredField("b");
+                this.serverPlayerGameModeGameType.setAccessible(true);
+            } catch (NoSuchFieldException e) {
+                Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
+                logger.warning("ServerPlayerGameMode#gameModeForPlayer's obfuscated name has changed!");
+                logger.warning("Please report this at https://github.com/Jikoo/OpenInv/issues");
+                logger.warning("Attempting to fall through using reflection. Please verify that SilentContainer does not fail.");
+                // N.B. gameModeForPlayer is (for now) declared before previousGameModeForPlayer so silent shouldn't break.
+                this.serverPlayerGameModeGameType = ReflectionHelper.grabFieldByType(ServerPlayerGameMode.class, GameType.class);
+            }
+        } catch (SecurityException e) {
+            Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
+            logger.warning("Unable to directly write player game mode! SilentContainer will fail.");
+            logger.log(java.util.logging.Level.WARNING, "Error obtaining GameType field", e);
+        }
+    }
+
+    @Override
+    public boolean isShulkerBlocked(@NotNull ShulkerBox shulkerBox) {
+        org.bukkit.World bukkitWorld = shulkerBox.getWorld();
+        if (!(bukkitWorld instanceof CraftWorld)) {
+            bukkitWorld = Bukkit.getWorld(bukkitWorld.getUID());
+        }
+
+        if (!(bukkitWorld instanceof CraftWorld craftWorld)) {
+            Exception exception = new IllegalStateException("AnySilentContainer access attempted on an unknown world!");
+            OpenInv.getPlugin(OpenInv.class).getLogger().log(java.util.logging.Level.WARNING, exception.getMessage(), exception);
+            return false;
+        }
+
+        final ServerLevel world = craftWorld.getHandle();
+        final BlockPos blockPosition = new BlockPos(shulkerBox.getX(), shulkerBox.getY(), shulkerBox.getZ());
+        final BlockEntity tile = world.getBlockEntity(blockPosition);
+
+        if (!(tile instanceof ShulkerBoxBlockEntity shulkerBoxBlockEntity)
+                || shulkerBoxBlockEntity.getAnimationStatus() != ShulkerBoxBlockEntity.AnimationStatus.CLOSED) {
+            return false;
+        }
+
+        BlockState blockState = world.getBlockState(blockPosition);
+
+        // See net.minecraft.world.level.block.ShulkerBoxBlock#canOpen
+        AABB boundingBox = Shulker.getProgressDeltaAabb(blockState.getValue(ShulkerBoxBlock.FACING), 0.0F, 0.5F)
+                .move(blockPosition)
+                .deflate(1.0E-6D);
+        return !world.noCollision(boundingBox);
+    }
+
+    @Override
+    public boolean activateContainer(
+            @NotNull final Player bukkitPlayer,
+            final boolean silentchest,
+            @NotNull final org.bukkit.block.Block bukkitBlock) {
+
+        // Silent ender chest is API-only
+        if (silentchest && bukkitBlock.getType() == Material.ENDER_CHEST) {
+            bukkitPlayer.openInventory(bukkitPlayer.getEnderChest());
+            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
+            return true;
+        }
+
+        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+
+        final net.minecraft.world.level.Level level = player.level();
+        final BlockPos blockPos = new BlockPos(bukkitBlock.getX(), bukkitBlock.getY(), bukkitBlock.getZ());
+        final BlockEntity blockEntity = level.getBlockEntity(blockPos);
+
+        if (blockEntity == null) {
+            return false;
+        }
+
+        if (blockEntity instanceof EnderChestBlockEntity enderChestTile) {
+            // Anychest ender chest. See net.minecraft.world.level.block.EnderChestBlock
+            PlayerEnderChestContainer enderChest = player.getEnderChestInventory();
+            enderChest.setActiveChest(enderChestTile);
+            player.openMenu(new SimpleMenuProvider((containerCounter, playerInventory, ignored) -> {
+                MenuType<?> containers = PlayerDataManager.getContainers(enderChest.getContainerSize());
+                int rows = enderChest.getContainerSize() / 9;
+                return new ChestMenu(containers, containerCounter, playerInventory, enderChest, rows);
+            }, Component.translatable(("container.enderchest"))));
+            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
+            return true;
+        }
+
+        if (!(blockEntity instanceof MenuProvider menuProvider)) {
+            return false;
+        }
+
+        BlockState blockState = level.getBlockState(blockPos);
+        Block block = blockState.getBlock();
+
+        if (block instanceof ChestBlock chestBlock) {
+
+            // boolean flag: do not check if chest is blocked
+            menuProvider = chestBlock.getMenuProvider(blockState, level, blockPos, true);
+
+            if (menuProvider == null) {
+                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
+                return false;
+            }
+
+            if (block instanceof TrappedChestBlock) {
+                bukkitPlayer.incrementStatistic(Statistic.TRAPPED_CHEST_TRIGGERED);
+            } else {
+                bukkitPlayer.incrementStatistic(Statistic.CHEST_OPENED);
+            }
+        }
+
+        if (block instanceof ShulkerBoxBlock) {
+            bukkitPlayer.incrementStatistic(Statistic.SHULKER_BOX_OPENED);
+        }
+
+        if (block instanceof BarrelBlock) {
+            bukkitPlayer.incrementStatistic(Statistic.OPEN_BARREL);
+        }
+
+        // AnyChest only - SilentChest not active, container unsupported, or unnecessary.
+        if (!silentchest || player.gameMode.getGameModeForPlayer() == GameType.SPECTATOR) {
+            player.openMenu(menuProvider);
+            return true;
+        }
+
+        // SilentChest requires access to setting players' game mode directly.
+        if (this.serverPlayerGameModeGameType == null) {
+            return false;
+        }
+
+        if (blockEntity instanceof RandomizableContainerBlockEntity lootable) {
+            if (lootable.lootTable != null) {
+                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
+                return false;
+            }
+        }
+
+        GameType gameType = player.gameMode.getGameModeForPlayer();
+        this.forceGameType(player, GameType.SPECTATOR);
+        player.openMenu(menuProvider);
+        this.forceGameType(player, gameType);
+        return true;
+    }
+
+    @Override
+    public void deactivateContainer(@NotNull final Player bukkitPlayer) {
+        if (this.serverPlayerGameModeGameType == null || bukkitPlayer.getGameMode() == GameMode.SPECTATOR) {
+            return;
+        }
+
+        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+
+        // Force game mode change without informing plugins or players.
+        // Regular game mode set calls GameModeChangeEvent and is cancellable.
+        GameType gameType = player.gameMode.getGameModeForPlayer();
+        this.forceGameType(player, GameType.SPECTATOR);
+
+        // ServerPlayer#closeContainer cannot be called without entering an
+        // infinite loop because this method is called during inventory close.
+        // From ServerPlayer#closeContainer -> CraftEventFactory#handleInventoryCloseEvent
+        player.containerMenu.transferTo(player.inventoryMenu, player.getBukkitEntity());
+        // From ServerPlayer#closeContainer
+        player.doCloseContainer();
+        // Regular inventory close will handle the rest - packet sending, etc.
+
+        // Revert forced game mode.
+        this.forceGameType(player, gameType);
+    }
+
+    private void forceGameType(final ServerPlayer player, final GameType gameMode) {
+        if (this.serverPlayerGameModeGameType == null) {
+            // No need to warn repeatedly, error on startup and lack of function should be enough.
+            return;
+        }
+        try {
+            this.serverPlayerGameModeGameType.setAccessible(true);
+            this.serverPlayerGameModeGameType.set(player.gameMode, gameMode);
+        } catch (IllegalArgumentException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+}
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R2;
+
+import com.mojang.logging.LogUtils;
+import net.minecraft.Util;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtIo;
+import net.minecraft.nbt.NumericTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.storage.PlayerDataStorage;
+import org.bukkit.craftbukkit.v1_20_R2.CraftServer;
+import org.bukkit.craftbukkit.v1_20_R2.entity.CraftPlayer;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.util.Set;
+
+public class OpenPlayer extends CraftPlayer {
+
+    private static final Set<String> RESET_TAGS = Set.of(
+        // net.minecraft.world.Entity#saveWithoutId(CompoundTag)
+        "CustomName",
+        "CustomNameVisible",
+        "Silent",
+        "NoGravity",
+        "Glowing",
+        "TicksFrozen",
+        "HasVisualFire",
+        "Tags",
+        "Passengers",
+        // net.minecraft.server.level.ServerPlayer#addAdditionalSaveData(CompoundTag)
+        // Intentional omissions to prevent mount loss: Attach, Entity, and RootVehicle
+        "warden_spawn_tracker",
+        "enteredNetherPosition",
+        "SpawnX",
+        "SpawnY",
+        "SpawnZ",
+        "SpawnForced",
+        "SpawnAngle",
+        "SpawnDimension",
+        // net.minecraft.world.entity.player.Player#addAdditionalSaveData(CompoundTag)
+        "ShoulderEntityLeft",
+        "ShoulderEntityRight",
+        "LastDeathLocation",
+        // net.minecraft.world.entity.LivingEntity#addAdditionalSaveData(CompoundTag)
+        "ActiveEffects", // Backwards compat: Renamed from 1.19
+        "active_effects",
+        "SleepingX",
+        "SleepingY",
+        "SleepingZ",
+        "Brain"
+    );
+
+    public OpenPlayer(CraftServer server, ServerPlayer entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public void loadData() {
+        PlayerDataManager.loadData(getHandle());
+    }
+
+    @Override
+    public void saveData() {
+        ServerPlayer player = this.getHandle();
+        // See net.minecraft.world.level.storage.PlayerDataStorage#save(EntityHuman)
+        try {
+            PlayerDataStorage worldNBTStorage = player.server.getPlayerList().playerIo;
+
+            CompoundTag oldData = isOnline() ? null : worldNBTStorage.load(player);
+            CompoundTag playerData = getWritableTag(oldData);
+            playerData = player.saveWithoutId(playerData);
+            setExtraData(playerData);
+
+            if (oldData != null) {
+                // Revert certain special data values when offline.
+                revertSpecialValues(playerData, oldData);
+            }
+
+            File file = File.createTempFile(player.getStringUUID() + "-", ".dat", worldNBTStorage.getPlayerDir());
+            NbtIo.writeCompressed(playerData, file);
+            File file1 = new File(worldNBTStorage.getPlayerDir(), player.getStringUUID() + ".dat");
+            File file2 = new File(worldNBTStorage.getPlayerDir(), player.getStringUUID() + ".dat_old");
+            Util.safeReplaceFile(file1, file, file2);
+        } catch (Exception e) {
+            LogUtils.getLogger().warn("Failed to save player data for {}: {}", player.getScoreboardName(), e);
+        }
+    }
+
+    @Contract("null -> new")
+    private @NotNull CompoundTag getWritableTag(@Nullable CompoundTag oldData) {
+        if (oldData == null) {
+            return new CompoundTag();
+        }
+
+        // Copy old data. This is a deep clone, so operating on it should be safe.
+        oldData = oldData.copy();
+
+        // Remove vanilla/server data that is not written every time.
+        oldData.getAllKeys().removeIf(key -> RESET_TAGS.contains(key) || key.startsWith("Bukkit"));
+
+        return oldData;
+    }
+
+    private void revertSpecialValues(@NotNull CompoundTag newData, @NotNull CompoundTag oldData) {
+        // Revert automatic updates to play timestamps.
+        copyValue(oldData, newData, "bukkit", "lastPlayed", NumericTag.class);
+        copyValue(oldData, newData, "Paper", "LastSeen", NumericTag.class);
+        copyValue(oldData, newData, "Paper", "LastLogin", NumericTag.class);
+    }
+
+    private <T extends Tag> void copyValue(
+        @NotNull CompoundTag source,
+        @NotNull CompoundTag target,
+        @NotNull String container,
+        @NotNull String key,
+        @NotNull Class<T> tagType) {
+        CompoundTag oldContainer = getTag(source, container, CompoundTag.class);
+        CompoundTag newContainer = getTag(target, container, CompoundTag.class);
+
+        // New container being null means the server implementation doesn't store this data.
+        if (newContainer == null) {
+            return;
+        }
+
+        // If old tag exists, copy it to new location, removing otherwise.
+        setTag(newContainer, key, getTag(oldContainer, key, tagType));
+    }
+
+    private <T extends Tag> @Nullable T getTag(
+        @Nullable CompoundTag container,
+        @NotNull String key,
+        @NotNull Class<T> dataType) {
+        if (container == null) {
+            return null;
+        }
+        Tag value = container.get(key);
+        if (value == null || !dataType.isAssignableFrom(value.getClass())) {
+            return null;
+        }
+        return dataType.cast(value);
+    }
+
+    private <T extends Tag> void setTag(
+        @NotNull CompoundTag container,
+        @NotNull String key,
+        @Nullable T data) {
+        if (data == null) {
+            container.remove(key);
+        } else {
+            container.put(key, data);
+        }
+    }
+
+}
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R2;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IPlayerDataManager;
+import com.lishid.openinv.internal.ISpecialInventory;
+import com.lishid.openinv.internal.OpenInventoryView;
+import com.mojang.authlib.GameProfile;
+import com.mojang.serialization.Dynamic;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtOps;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ClientInformation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.ChatVisiblity;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.dimension.DimensionType;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_20_R2.CraftServer;
+import org.bukkit.craftbukkit.v1_20_R2.CraftWorld;
+import org.bukkit.craftbukkit.v1_20_R2.entity.CraftPlayer;
+import org.bukkit.craftbukkit.v1_20_R2.event.CraftEventFactory;
+import org.bukkit.craftbukkit.v1_20_R2.inventory.CraftContainer;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+public class PlayerDataManager implements IPlayerDataManager {
+
+    private static boolean paper;
+
+    static {
+        try {
+            Class.forName("io.papermc.paper.configuration.Configuration");
+            paper = true;
+        } catch (ClassNotFoundException ignored) {
+            paper = false;
+        }
+    }
+
+    private @Nullable Field bukkitEntity;
+
+    public PlayerDataManager() {
+        try {
+            bukkitEntity = Entity.class.getDeclaredField("bukkitEntity");
+        } catch (NoSuchFieldException e) {
+            Logger logger = JavaPlugin.getPlugin(OpenInv.class).getLogger();
+            logger.warning("Unable to obtain field to inject custom save process - certain player data may be lost when saving!");
+            logger.log(java.util.logging.Level.WARNING, e.getMessage(), e);
+            bukkitEntity = null;
+        }
+    }
+
+    public static @NotNull ServerPlayer getHandle(final Player player) {
+        if (player instanceof CraftPlayer) {
+            return ((CraftPlayer) player).getHandle();
+        }
+
+        Server server = player.getServer();
+        ServerPlayer nmsPlayer = null;
+
+        if (server instanceof CraftServer) {
+            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getUniqueId());
+        }
+
+        if (nmsPlayer == null) {
+            // Could use reflection to examine fields, but it's honestly not worth the bother.
+            throw new RuntimeException("Unable to fetch EntityPlayer from Player implementation " + player.getClass().getName());
+        }
+
+        return nmsPlayer;
+    }
+
+    @Override
+    public @Nullable Player loadPlayer(@NotNull final OfflinePlayer offline) {
+        // Ensure player has data
+        if (!offline.hasPlayedBefore()) {
+            return null;
+        }
+
+        MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
+        ServerLevel worldServer = server.getLevel(Level.OVERWORLD);
+
+        if (worldServer == null) {
+            return null;
+        }
+
+        // Create a new ServerPlayer.
+        ServerPlayer entity = createNewPlayer(server, worldServer, offline);
+
+        // Stop listening for advancement progression - if this is not cleaned up, loading causes a memory leak.
+        entity.getAdvancements().stopListening();
+
+        // Try to load the player's data.
+        if (loadData(entity)) {
+            // If data is loaded successfully, return the Bukkit entity.
+            return entity.getBukkitEntity();
+        }
+
+        return null;
+    }
+
+    private @NotNull ServerPlayer createNewPlayer(
+        @NotNull MinecraftServer server,
+        @NotNull ServerLevel worldServer,
+        @NotNull final OfflinePlayer offline) {
+        // See net.minecraft.server.players.PlayerList#canPlayerLogin(ServerLoginPacketListenerImpl, GameProfile)
+        // See net.minecraft.server.network.ServerLoginPacketListenerImpl#handleHello(ServerboundHelloPacket)
+        GameProfile profile = new GameProfile(offline.getUniqueId(),
+            offline.getName() != null ? offline.getName() : offline.getUniqueId().toString());
+
+        ClientInformation dummyInfo = new ClientInformation(
+            "en_us",
+            1, // Reduce distance just in case.
+            ChatVisiblity.HIDDEN, // Don't accept chat.
+            false,
+            ServerPlayer.DEFAULT_MODEL_CUSTOMIZATION,
+            ServerPlayer.DEFAULT_MAIN_HAND,
+            true,
+            false // Don't list in player list (not that this player is in the list anyway).
+        );
+
+        ServerPlayer entity = new ServerPlayer(server, worldServer, profile, dummyInfo);
+
+        try {
+            injectPlayer(entity);
+        } catch (IllegalAccessException e) {
+            JavaPlugin.getPlugin(OpenInv.class).getLogger().log(
+                java.util.logging.Level.WARNING,
+                e,
+                () -> "Unable to inject ServerPlayer, certain player data may be lost when saving!");
+        }
+
+        return entity;
+    }
+
+    static boolean loadData(@NotNull ServerPlayer player) {
+        // See CraftPlayer#loadData
+        CompoundTag loadedData = player.server.getPlayerList().playerIo.load(player);
+
+        if (loadedData == null) {
+            // Exceptions with loading are logged by Mojang.
+            return false;
+        }
+
+        // Read basic data into the player.
+        player.load(loadedData);
+        // Also read "extra" data.
+        player.readAdditionalSaveData(loadedData);
+        // Game type settings are also loaded separately.
+        player.loadGameTypes(loadedData);
+
+        if (paper) {
+            // Paper: world is not loaded by ServerPlayer#load(CompoundTag).
+            parseWorld(player, loadedData);
+        }
+
+        return true;
+    }
+
+    private static void parseWorld(@NotNull ServerPlayer player, @NotNull CompoundTag loadedData) {
+        // See PlayerList#placeNewPlayer
+        World bukkitWorld;
+        if (loadedData.contains("WorldUUIDMost") && loadedData.contains("WorldUUIDLeast")) {
+            // Modern Bukkit world.
+            bukkitWorld = org.bukkit.Bukkit.getServer().getWorld(new UUID(loadedData.getLong("WorldUUIDMost"), loadedData.getLong("WorldUUIDLeast")));
+        } else if (loadedData.contains("world", net.minecraft.nbt.Tag.TAG_STRING)) {
+            // Legacy Bukkit world.
+            bukkitWorld = org.bukkit.Bukkit.getServer().getWorld(loadedData.getString("world"));
+        } else {
+            // Vanilla player data.
+            DimensionType.parseLegacy(new Dynamic<>(NbtOps.INSTANCE, loadedData.get("Dimension")))
+                .resultOrPartial(JavaPlugin.getPlugin(OpenInv.class).getLogger()::warning)
+                .map(player.server::getLevel)
+                // If ServerLevel exists, set, otherwise move to spawn.
+                .ifPresentOrElse(player::setServerLevel, () -> player.spawnIn(null));
+            return;
+        }
+        if (bukkitWorld == null) {
+            player.spawnIn(null);
+            return;
+        }
+        player.setServerLevel(((CraftWorld) bukkitWorld).getHandle());
+    }
+
+    private void injectPlayer(ServerPlayer player) throws IllegalAccessException {
+        if (bukkitEntity == null) {
+            return;
+        }
+
+        bukkitEntity.setAccessible(true);
+
+        bukkitEntity.set(player, new OpenPlayer(player.server.server, player));
+    }
+
+    @Override
+    public @NotNull Player inject(@NotNull Player player) {
+        try {
+            ServerPlayer nmsPlayer = getHandle(player);
+            if (nmsPlayer.getBukkitEntity() instanceof OpenPlayer openPlayer) {
+                return openPlayer;
+            }
+            injectPlayer(nmsPlayer);
+            return nmsPlayer.getBukkitEntity();
+        } catch (IllegalAccessException e) {
+            JavaPlugin.getPlugin(OpenInv.class).getLogger().log(
+                java.util.logging.Level.WARNING,
+                e,
+                () -> "Unable to inject ServerPlayer, certain player data may be lost when saving!");
+            return player;
+        }
+    }
+
+    @Override
+    public @Nullable InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {
+
+        ServerPlayer nmsPlayer = getHandle(player);
+
+        if (nmsPlayer.connection == null) {
+            return null;
+        }
+
+        InventoryView view = getView(player, inventory);
+
+        if (view == null) {
+            return player.openInventory(inventory.getBukkitInventory());
+        }
+
+        AbstractContainerMenu container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
+            @Override
+            public MenuType<?> getType() {
+                return getContainers(inventory.getBukkitInventory().getSize());
+            }
+        };
+
+        container.setTitle(Component.literal(view.getTitle()));
+        container = CraftEventFactory.callInventoryOpenEvent(nmsPlayer, container);
+
+        if (container == null) {
+            return null;
+        }
+
+        nmsPlayer.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(),
+                Component.literal(container.getBukkitView().getTitle())));
+        nmsPlayer.containerMenu = container;
+        nmsPlayer.initMenu(container);
+
+        return container.getBukkitView();
+
+    }
+
+    private @Nullable InventoryView getView(Player player, ISpecialInventory inventory) {
+        if (inventory instanceof SpecialEnderChest) {
+            return new OpenInventoryView(player, inventory, "container.enderchest", "'s Ender Chest");
+        } else if (inventory instanceof SpecialPlayerInventory) {
+            return new OpenInventoryView(player, inventory, "container.player", "'s Inventory");
+        } else {
+            return null;
+        }
+    }
+
+    static @NotNull MenuType<?> getContainers(int inventorySize) {
+
+        return switch (inventorySize) {
+            case 9 -> MenuType.GENERIC_9x1;
+            case 18 -> MenuType.GENERIC_9x2;
+            case 36 -> MenuType.GENERIC_9x4; // PLAYER
+            case 41, 45 -> MenuType.GENERIC_9x5;
+            case 54 -> MenuType.GENERIC_9x6;
+            default -> MenuType.GENERIC_9x3; // Default 27-slot inventory
+        };
+    }
+
+    @Override
+    public int convertToPlayerSlot(InventoryView view, int rawSlot) {
+        int topSize = view.getTopInventory().getSize();
+        if (topSize <= rawSlot) {
+            // Slot is not inside special inventory, use Bukkit logic.
+            return view.convertSlot(rawSlot);
+        }
+
+        // Main inventory, slots 0-26 -> 9-35
+        if (rawSlot < 27) {
+            return rawSlot + 9;
+        }
+        // Hotbar, slots 27-35 -> 0-8
+        if (rawSlot < 36) {
+            return rawSlot - 27;
+        }
+        // Armor, slots 36-39 -> 39-36
+        if (rawSlot < 40) {
+            return 36 + (39 - rawSlot);
+        }
+        // Off hand
+        if (rawSlot == 40) {
+            return 40;
+        }
+        // Drop slots, "out of inventory"
+        return -1;
+    }
+
+}
@@ -0,0 +1,350 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R2;
+
+import com.lishid.openinv.internal.ISpecialEnderChest;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.ContainerListener;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.player.StackedContents;
+import net.minecraft.world.inventory.PlayerEnderChestContainer;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.entity.EnderChestBlockEntity;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_20_R2.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_20_R2.inventory.CraftInventory;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpecialEnderChest {
+
+    private final CraftInventory inventory;
+    private ServerPlayer owner;
+    private NonNullList<ItemStack> items;
+    private boolean playerOnline;
+
+    public SpecialEnderChest(final org.bukkit.entity.Player player, final Boolean online) {
+        super(PlayerDataManager.getHandle(player));
+        this.inventory = new CraftInventory(this);
+        this.owner = PlayerDataManager.getHandle(player);
+        this.playerOnline = online;
+        this.items = this.owner.getEnderChestInventory().items;
+    }
+
+    @Override
+    public @NotNull CraftInventory getBukkitInventory() {
+        return inventory;
+    }
+
+    @Override
+    public void setPlayerOffline() {
+        this.playerOnline = false;
+    }
+
+    @Override
+    public void setPlayerOnline(@NotNull final org.bukkit.entity.Player player) {
+        if (this.playerOnline) {
+            return;
+        }
+
+        ServerPlayer offlinePlayer = this.owner;
+        ServerPlayer onlinePlayer = PlayerDataManager.getHandle(player);
+
+        // Set owner to new player.
+        this.owner = onlinePlayer;
+
+        // Set player's ender chest contents to our modified contents.
+        PlayerEnderChestContainer onlineEnderChest = onlinePlayer.getEnderChestInventory();
+        for (int i = 0; i < onlineEnderChest.getContainerSize(); ++i) {
+            onlineEnderChest.setItem(i, this.items.get(i));
+        }
+
+        // Set our item array to the new inventory's array.
+        this.items = onlineEnderChest.items;
+
+        // Add viewers to new inventory.
+        onlineEnderChest.transaction.addAll(offlinePlayer.getEnderChestInventory().transaction);
+
+        this.playerOnline = true;
+    }
+
+    @Override
+    public @NotNull org.bukkit.entity.Player getPlayer() {
+        return owner.getBukkitEntity();
+    }
+
+    @Override
+    public void setChanged() {
+        this.owner.getEnderChestInventory().setChanged();
+    }
+
+    @Override
+    public List<ItemStack> getContents() {
+        return this.items;
+    }
+
+    @Override
+    public void onOpen(CraftHumanEntity who) {
+        this.owner.getEnderChestInventory().onOpen(who);
+    }
+
+    @Override
+    public void onClose(CraftHumanEntity who) {
+        this.owner.getEnderChestInventory().onClose(who);
+    }
+
+    @Override
+    public List<HumanEntity> getViewers() {
+        return this.owner.getEnderChestInventory().getViewers();
+    }
+
+    @Override
+    public boolean stillValid(Player player) {
+        return true;
+    }
+
+    @Override
+    public void setActiveChest(EnderChestBlockEntity enderChest) {
+        this.owner.getEnderChestInventory().setActiveChest(enderChest);
+    }
+
+    @Override
+    public boolean isActiveChest(EnderChestBlockEntity enderChest) {
+        return this.owner.getEnderChestInventory().isActiveChest(enderChest);
+    }
+
+    @Override
+    public int getMaxStackSize() {
+        return this.owner.getEnderChestInventory().getMaxStackSize();
+    }
+
+    @Override
+    public void setMaxStackSize(int i) {
+        this.owner.getEnderChestInventory().setMaxStackSize(i);
+    }
+
+    @Override
+    public InventoryHolder getOwner() {
+        return this.owner.getEnderChestInventory().getOwner();
+    }
+
+    @Override
+    public @Nullable Location getLocation() {
+        return null;
+    }
+
+    @Override
+    public void addListener(ContainerListener listener) {
+        this.owner.getEnderChestInventory().addListener(listener);
+    }
+
+    @Override
+    public void removeListener(ContainerListener listener) {
+        this.owner.getEnderChestInventory().removeListener(listener);
+    }
+
+    @Override
+    public ItemStack getItem(int i) {
+        return i >= 0 && i < this.items.size() ? this.items.get(i) : ItemStack.EMPTY;
+    }
+
+    @Override
+    public ItemStack removeItem(int i, int j) {
+        ItemStack itemstack = ContainerHelper.removeItem(this.items, i, j);
+        if (!itemstack.isEmpty()) {
+            this.setChanged();
+        }
+
+        return itemstack;
+    }
+
+    @Override
+    public ItemStack addItem(ItemStack itemstack) {
+        ItemStack localItem = itemstack.copy();
+        this.moveItemToOccupiedSlotsWithSameType(localItem);
+        if (localItem.isEmpty()) {
+            return ItemStack.EMPTY;
+        } else {
+            this.moveItemToEmptySlots(localItem);
+            return localItem.isEmpty() ? ItemStack.EMPTY : localItem;
+        }
+    }
+
+    @Override
+    public boolean canAddItem(ItemStack itemstack) {
+        for (ItemStack itemstack1 : this.items) {
+            if (itemstack1.isEmpty() || ItemStack.isSameItemSameTags(itemstack1, itemstack) && itemstack1.getCount() < itemstack1.getMaxStackSize()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private void moveItemToEmptySlots(ItemStack itemstack) {
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            ItemStack localItem = this.getItem(i);
+            if (localItem.isEmpty()) {
+                this.setItem(i, itemstack.copy());
+                itemstack.setCount(0);
+                return;
+            }
+        }
+    }
+
+    private void moveItemToOccupiedSlotsWithSameType(ItemStack itemstack) {
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            ItemStack localItem = this.getItem(i);
+            if (ItemStack.isSameItemSameTags(localItem, itemstack)) {
+                this.moveItemsBetweenStacks(itemstack, localItem);
+                if (itemstack.isEmpty()) {
+                    return;
+                }
+            }
+        }
+    }
+
+    private void moveItemsBetweenStacks(ItemStack itemstack, ItemStack itemstack1) {
+        int i = Math.min(this.getMaxStackSize(), itemstack1.getMaxStackSize());
+        int j = Math.min(itemstack.getCount(), i - itemstack1.getCount());
+        if (j > 0) {
+            itemstack1.grow(j);
+            itemstack.shrink(j);
+            this.setChanged();
+        }
+    }
+
+    @Override
+    public ItemStack removeItemNoUpdate(int i) {
+        ItemStack itemstack = this.items.get(i);
+        if (itemstack.isEmpty()) {
+            return ItemStack.EMPTY;
+        } else {
+            this.items.set(i, ItemStack.EMPTY);
+            return itemstack;
+        }
+    }
+
+    @Override
+    public void setItem(int i, ItemStack itemstack) {
+        this.items.set(i, itemstack);
+        if (!itemstack.isEmpty() && itemstack.getCount() > this.getMaxStackSize()) {
+            itemstack.setCount(this.getMaxStackSize());
+        }
+
+        this.setChanged();
+    }
+
+    @Override
+    public int getContainerSize() {
+        return this.owner.getEnderChestInventory().getContainerSize();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.items.stream().allMatch(ItemStack::isEmpty);
+    }
+
+    @Override
+    public void startOpen(Player player) {
+    }
+
+    @Override
+    public void stopOpen(Player player) {
+    }
+
+    @Override
+    public boolean canPlaceItem(int i, ItemStack itemstack) {
+        return true;
+    }
+
+    @Override
+    public void clearContent() {
+        this.items.clear();
+        this.setChanged();
+    }
+
+    @Override
+    public void fillStackedContents(StackedContents stackedContents) {
+        for (ItemStack itemstack : this.items) {
+            stackedContents.accountStack(itemstack);
+        }
+
+    }
+
+    @Override
+    public List<ItemStack> removeAllItems() {
+        List<ItemStack> list = this.items.stream().filter(Predicate.not(ItemStack::isEmpty)).collect(Collectors.toList());
+        this.clearContent();
+        return list;
+    }
+
+    @Override
+    public ItemStack removeItemType(Item item, int i) {
+        ItemStack itemstack = new ItemStack(item, 0);
+
+        for(int j = this.getContainerSize() - 1; j >= 0; --j) {
+            ItemStack localItem = this.getItem(j);
+            if (localItem.getItem().equals(item)) {
+                int k = i - itemstack.getCount();
+                ItemStack splitItem = localItem.split(k);
+                itemstack.grow(splitItem.getCount());
+                if (itemstack.getCount() == i) {
+                    break;
+                }
+            }
+        }
+
+        if (!itemstack.isEmpty()) {
+            this.setChanged();
+        }
+
+        return itemstack;
+    }
+
+    @Override
+    public String toString() {
+        return this.items.stream().filter((itemStack) -> !itemStack.isEmpty()).toList().toString();
+    }
+
+    @Override
+    public void fromTag(ListTag listTag) {
+        for (int i = 0; i < this.getContainerSize(); ++i) {
+            this.setItem(i, ItemStack.EMPTY);
+        }
+
+        for (int i = 0; i < listTag.size(); ++i) {
+            CompoundTag compoundTag = listTag.getCompound(i);
+            int j = compoundTag.getByte("Slot") & 255;
+            if (j < this.getContainerSize()) {
+                this.setItem(j, ItemStack.of(compoundTag));
+            }
+        }
+
+    }
+
+}
@@ -0,0 +1,806 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R2;
+
+import com.google.common.collect.ImmutableList;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import net.minecraft.CrashReport;
+import net.minecraft.CrashReportCategory;
+import net.minecraft.ReportedException;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.tags.DamageTypeTags;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.Container;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.player.StackedContents;
+import net.minecraft.world.item.ArmorItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.state.BlockState;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_20_R2.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_20_R2.inventory.CraftInventory;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class SpecialPlayerInventory extends Inventory implements ISpecialPlayerInventory {
+
+    private final CraftInventory inventory;
+    private boolean playerOnline;
+    private Player player;
+    private NonNullList<ItemStack> items;
+    private NonNullList<ItemStack> armor;
+    private NonNullList<ItemStack> offhand;
+    private List<NonNullList<ItemStack>> compartments;
+
+    public SpecialPlayerInventory(@NotNull org.bukkit.entity.Player bukkitPlayer, @NotNull Boolean online) {
+        super(PlayerDataManager.getHandle(bukkitPlayer));
+        this.inventory = new CraftInventory(this);
+        this.playerOnline = online;
+        this.player = super.player;
+        this.selected = player.getInventory().selected;
+        this.items = this.player.getInventory().items;
+        this.armor = this.player.getInventory().armor;
+        this.offhand = this.player.getInventory().offhand;
+        this.compartments = ImmutableList.of(this.items, this.armor, this.offhand);
+    }
+
+    @Override
+    public void setPlayerOnline(@NotNull org.bukkit.entity.Player player) {
+        if (this.playerOnline) {
+            return;
+        }
+
+        Player offlinePlayer = this.player;
+        Player onlinePlayer = PlayerDataManager.getHandle(player);
+        onlinePlayer.getInventory().transaction.addAll(this.transaction);
+
+        // Set owner to new player.
+        this.player = onlinePlayer;
+
+        // Set player's inventory contents to our modified contents.
+        Inventory onlineInventory = onlinePlayer.getInventory();
+        for (int i = 0; i < getContainerSize(); ++i) {
+            onlineInventory.setItem(i, getRawItem(i));
+        }
+        onlineInventory.selected = this.selected;
+
+        // Set our item arrays to the new inventory's arrays.
+        this.items = onlineInventory.items;
+        this.armor = onlineInventory.armor;
+        this.offhand = onlineInventory.offhand;
+        this.compartments = ImmutableList.of(this.items, this.armor, this.offhand);
+
+        // Add existing viewers to new viewer list.
+        Inventory offlineInventory = offlinePlayer.getInventory();
+        // Remove self from listing - player is always a viewer of their own inventory, prevent duplicates.
+        offlineInventory.transaction.remove(offlinePlayer.getBukkitEntity());
+        onlineInventory.transaction.addAll(offlineInventory.transaction);
+
+        this.playerOnline = true;
+    }
+
+    @Override
+    public @NotNull CraftInventory getBukkitInventory() {
+        return this.inventory;
+    }
+
+    @Override
+    public void setPlayerOffline() {
+        this.playerOnline = false;
+    }
+
+    @Override
+    public @NotNull HumanEntity getPlayer() {
+        return this.player.getBukkitEntity();
+    }
+
+    private @NotNull ItemStack getRawItem(int i) {
+        if (i < 0) {
+            return ItemStack.EMPTY;
+        }
+
+        NonNullList<ItemStack> list;
+        for (Iterator<NonNullList<ItemStack>> iterator = this.compartments.iterator(); iterator.hasNext(); i -= list.size()) {
+            list = iterator.next();
+            if (i < list.size()) {
+                return list.get(i);
+            }
+        }
+
+        return ItemStack.EMPTY;
+    }
+
+    private void setRawItem(int i, @NotNull ItemStack itemStack) {
+        if (i < 0) {
+            return;
+        }
+
+        NonNullList<ItemStack> list;
+        for (Iterator<NonNullList<ItemStack>> iterator = this.compartments.iterator(); iterator.hasNext(); i -= list.size()) {
+            list = iterator.next();
+            if (i < list.size()) {
+                list.set(i, itemStack);
+            }
+        }
+    }
+
+    private record IndexedCompartment(@Nullable NonNullList<ItemStack> compartment, int index) {}
+
+    private @NotNull SpecialPlayerInventory.IndexedCompartment getIndexedContent(int index) {
+        if (index < items.size()) {
+            return new IndexedCompartment(items, getReversedItemSlotNum(index));
+        }
+
+        index -= items.size();
+
+        if (index < armor.size()) {
+            return new IndexedCompartment(armor, getReversedArmorSlotNum(index));
+        }
+
+        index -= armor.size();
+
+        if (index < offhand.size()) {
+            return new IndexedCompartment(offhand, index);
+        }
+
+        index -= offhand.size();
+
+        return new IndexedCompartment(null, index);
+    }
+
+    private int getReversedArmorSlotNum(final int i) {
+        if (i == 0) {
+            return 3;
+        }
+        if (i == 1) {
+            return 2;
+        }
+        if (i == 2) {
+            return 1;
+        }
+        if (i == 3) {
+            return 0;
+        }
+        return i;
+    }
+
+    private int getReversedItemSlotNum(final int i) {
+        if (i >= 27) {
+            return i - 27;
+        }
+        return i + 9;
+    }
+
+    private boolean contains(Predicate<ItemStack> predicate) {
+        return this.compartments.stream().flatMap(NonNullList::stream).anyMatch(predicate);
+    }
+
+    @Override
+    public List<ItemStack> getArmorContents() {
+        return this.armor;
+    }
+
+    @Override
+    public void onOpen(CraftHumanEntity who) {
+        this.player.getInventory().onOpen(who);
+    }
+
+    @Override
+    public void onClose(CraftHumanEntity who) {
+        this.player.getInventory().onClose(who);
+    }
+
+    @Override
+    public List<HumanEntity> getViewers() {
+        return this.player.getInventory().getViewers();
+    }
+
+    @Override
+    public InventoryHolder getOwner() {
+        return this.player.getBukkitEntity();
+    }
+
+    @Override
+    public int getMaxStackSize() {
+        return this.player.getInventory().getMaxStackSize();
+    }
+
+    @Override
+    public void setMaxStackSize(int size) {
+        this.player.getInventory().setMaxStackSize(size);
+    }
+
+    @Override
+    public Location getLocation() {
+        return this.player.getBukkitEntity().getLocation();
+    }
+
+    @Override
+    public boolean hasCustomName() {
+        return false;
+    }
+
+    @Override
+    public List<ItemStack> getContents() {
+        return this.compartments.stream().flatMap(Collection::stream).collect(Collectors.toList());
+    }
+
+    @Override
+    public ItemStack getSelected() {
+        return isHotbarSlot(this.selected) ? this.items.get(this.selected) : ItemStack.EMPTY;
+    }
+
+    private boolean hasRemainingSpaceForItem(ItemStack itemstack, ItemStack itemstack1) {
+        return !itemstack.isEmpty() && ItemStack.isSameItemSameTags(itemstack, itemstack1) && itemstack.isStackable() && itemstack.getCount() < itemstack.getMaxStackSize() && itemstack.getCount() < this.getMaxStackSize();
+    }
+
+    @Override
+    public int canHold(ItemStack itemstack) {
+        int remains = itemstack.getCount();
+
+        for (int i = 0; i < this.items.size(); ++i) {
+            ItemStack itemstack1 = this.getRawItem(i);
+            if (itemstack1.isEmpty()) {
+                return itemstack.getCount();
+            }
+
+            if (this.hasRemainingSpaceForItem(itemstack1, itemstack)) {
+                remains -= (itemstack1.getMaxStackSize() < this.getMaxStackSize() ? itemstack1.getMaxStackSize() : this.getMaxStackSize()) - itemstack1.getCount();
+            }
+
+            if (remains <= 0) {
+                return itemstack.getCount();
+            }
+        }
+
+        ItemStack offhandItemStack = this.getRawItem(this.items.size() + this.armor.size());
+        if (this.hasRemainingSpaceForItem(offhandItemStack, itemstack)) {
+            remains -= (offhandItemStack.getMaxStackSize() < this.getMaxStackSize() ? offhandItemStack.getMaxStackSize() : this.getMaxStackSize()) - offhandItemStack.getCount();
+        }
+
+        return remains <= 0 ? itemstack.getCount() : itemstack.getCount() - remains;
+    }
+
+    @Override
+    public int getFreeSlot() {
+        for(int i = 0; i < this.items.size(); ++i) {
+            if (this.items.get(i).isEmpty()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public void setPickedItem(ItemStack itemstack) {
+        int i = this.findSlotMatchingItem(itemstack);
+        if (isHotbarSlot(i)) {
+            this.selected = i;
+        } else if (i == -1) {
+            this.selected = this.getSuitableHotbarSlot();
+            if (!this.items.get(this.selected).isEmpty()) {
+                int j = this.getFreeSlot();
+                if (j != -1) {
+                    this.items.set(j, this.items.get(this.selected));
+                }
+            }
+
+            this.items.set(this.selected, itemstack);
+        } else {
+            this.pickSlot(i);
+        }
+
+    }
+
+    @Override
+    public void pickSlot(int i) {
+        this.selected = this.getSuitableHotbarSlot();
+        ItemStack itemstack = this.items.get(this.selected);
+        this.items.set(this.selected, this.items.get(i));
+        this.items.set(i, itemstack);
+    }
+
+    @Override
+    public int findSlotMatchingItem(ItemStack itemstack) {
+        for(int i = 0; i < this.items.size(); ++i) {
+            if (!this.items.get(i).isEmpty() && ItemStack.isSameItemSameTags(itemstack, this.items.get(i))) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public int findSlotMatchingUnusedItem(ItemStack itemStack) {
+        for(int i = 0; i < this.items.size(); ++i) {
+            ItemStack localItem = this.items.get(i);
+            if (!this.items.get(i).isEmpty() && ItemStack.isSameItemSameTags(itemStack, this.items.get(i)) && !this.items.get(i).isDamaged() && !localItem.isEnchanted() && !localItem.hasCustomHoverName()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public int getSuitableHotbarSlot() {
+        int i;
+        int j;
+        for(j = 0; j < 9; ++j) {
+            i = (this.selected + j) % 9;
+            if (this.items.get(i).isEmpty()) {
+                return i;
+            }
+        }
+
+        for(j = 0; j < 9; ++j) {
+            i = (this.selected + j) % 9;
+            if (!this.items.get(i).isEnchanted()) {
+                return i;
+            }
+        }
+
+        return this.selected;
+    }
+
+    @Override
+    public void swapPaint(double d0) {
+        if (d0 > 0.0D) {
+            d0 = 1.0D;
+        }
+
+        if (d0 < 0.0D) {
+            d0 = -1.0D;
+        }
+
+        this.selected = (int) (this.selected - d0);
+
+        while (this.selected < 0) {
+            this.selected += 9;
+        }
+
+        while(this.selected >= 9) {
+            this.selected -= 9;
+        }
+    }
+
+    @Override
+    public int clearOrCountMatchingItems(Predicate<ItemStack> predicate, int i, Container container) {
+        byte b0 = 0;
+        boolean flag = i == 0;
+        int j = b0 + ContainerHelper.clearOrCountMatchingItems(this, predicate, i - b0, flag);
+        j += ContainerHelper.clearOrCountMatchingItems(container, predicate, i - j, flag);
+        ItemStack itemstack = this.player.containerMenu.getCarried();
+        j += ContainerHelper.clearOrCountMatchingItems(itemstack, predicate, i - j, flag);
+        if (itemstack.isEmpty()) {
+            this.player.containerMenu.setCarried(ItemStack.EMPTY);
+        }
+
+        return j;
+    }
+
+    private int addResource(ItemStack itemstack) {
+        int i = this.getSlotWithRemainingSpace(itemstack);
+        if (i == -1) {
+            i = this.getFreeSlot();
+        }
+
+        return i == -1 ? itemstack.getCount() : this.addResource(i, itemstack);
+    }
+
+    private int addResource(int i, ItemStack itemstack) {
+        Item item = itemstack.getItem();
+        int j = itemstack.getCount();
+        ItemStack localItemStack = this.getRawItem(i);
+        if (localItemStack.isEmpty()) {
+            localItemStack = new ItemStack(item, 0);
+            if (itemstack.hasTag()) {
+                // hasTag ensures tag not null
+                //noinspection ConstantConditions
+                localItemStack.setTag(itemstack.getTag().copy());
+            }
+
+            this.setRawItem(i, localItemStack);
+        }
+
+        int k = Math.min(j, localItemStack.getMaxStackSize() - localItemStack.getCount());
+
+        if (k > this.getMaxStackSize() - localItemStack.getCount()) {
+            k = this.getMaxStackSize() - localItemStack.getCount();
+        }
+
+        if (k != 0) {
+            j -= k;
+            localItemStack.grow(k);
+            localItemStack.setPopTime(5);
+        }
+
+        return j;
+    }
+
+    @Override
+    public int getSlotWithRemainingSpace(ItemStack itemstack) {
+        if (this.hasRemainingSpaceForItem(this.getRawItem(this.selected), itemstack)) {
+            return this.selected;
+        } else if (this.hasRemainingSpaceForItem(this.getRawItem(40), itemstack)) {
+            return 40;
+        } else {
+            for(int i = 0; i < this.items.size(); ++i) {
+                if (this.hasRemainingSpaceForItem(this.items.get(i), itemstack)) {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+    }
+
+    @Override
+    public void tick() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                if (!compartment.get(i).isEmpty()) {
+                    compartment.get(i).inventoryTick(this.player.level(), this.player, i, this.selected == i);
+                }
+            }
+        }
+
+    }
+
+    @Override
+    public boolean add(ItemStack itemStack) {
+        return this.add(-1, itemStack);
+    }
+
+    @Override
+    public boolean add(int i, ItemStack itemStack) {
+        if (itemStack.isEmpty()) {
+            return false;
+        } else {
+            try {
+                if (itemStack.isDamaged()) {
+                    if (i == -1) {
+                        i = this.getFreeSlot();
+                    }
+
+                    if (i >= 0) {
+                        this.items.set(i, itemStack.copy());
+                        this.items.get(i).setPopTime(5);
+                        itemStack.setCount(0);
+                        return true;
+                    } else if (this.player.getAbilities().instabuild) {
+                        itemStack.setCount(0);
+                        return true;
+                    } else {
+                        return false;
+                    }
+                } else {
+                    int j;
+                    do {
+                        j = itemStack.getCount();
+                        if (i == -1) {
+                            itemStack.setCount(this.addResource(itemStack));
+                        } else {
+                            itemStack.setCount(this.addResource(i, itemStack));
+                        }
+                    } while(!itemStack.isEmpty() && itemStack.getCount() < j);
+
+                    if (itemStack.getCount() == j && this.player.getAbilities().instabuild) {
+                        itemStack.setCount(0);
+                        return true;
+                    } else {
+                        return itemStack.getCount() < j;
+                    }
+                }
+            } catch (Throwable var6) {
+                CrashReport crashReport = CrashReport.forThrowable(var6, "Adding item to inventory");
+                CrashReportCategory crashReportCategory = crashReport.addCategory("Item being added");
+                crashReportCategory.setDetail("Item ID", Item.getId(itemStack.getItem()));
+                crashReportCategory.setDetail("Item data", itemStack.getDamageValue());
+                crashReportCategory.setDetail("Item name", () -> itemStack.getHoverName().getString());
+                throw new ReportedException(crashReport);
+            }
+        }
+    }
+
+    @Override
+    public void placeItemBackInInventory(ItemStack itemStack) {
+        this.placeItemBackInInventory(itemStack, true);
+    }
+
+    @Override
+    public void placeItemBackInInventory(ItemStack itemStack, boolean flag) {
+        while(true) {
+            if (!itemStack.isEmpty()) {
+                int i = this.getSlotWithRemainingSpace(itemStack);
+                if (i == -1) {
+                    i = this.getFreeSlot();
+                }
+
+                if (i != -1) {
+                    int j = itemStack.getMaxStackSize() - this.getRawItem(i).getCount();
+                    if (this.add(i, itemStack.split(j)) && flag && this.player instanceof ServerPlayer) {
+                        ((ServerPlayer)this.player).connection.send(new ClientboundContainerSetSlotPacket(-2, 0, i, this.getRawItem(i)));
+                    }
+                    continue;
+                }
+
+                this.player.drop(itemStack, false);
+            }
+
+            return;
+        }
+    }
+
+    @Override
+    public ItemStack removeItem(int rawIndex, final int j) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null
+                || indexedCompartment.compartment().get(indexedCompartment.index()).isEmpty()) {
+            return ItemStack.EMPTY;
+        }
+
+        return ContainerHelper.removeItem(indexedCompartment.compartment(), indexedCompartment.index(), j);
+    }
+
+    @Override
+    public void removeItem(ItemStack itemStack) {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                if (compartment.get(i) == itemStack) {
+                    compartment.set(i, ItemStack.EMPTY);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public ItemStack removeItemNoUpdate(int rawIndex) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            return ItemStack.EMPTY;
+        }
+
+        ItemStack removed = indexedCompartment.compartment().set(indexedCompartment.index(), ItemStack.EMPTY);
+
+        if (removed.isEmpty()) {
+            return ItemStack.EMPTY;
+        }
+
+        return removed;
+    }
+
+    @Override
+    public void setItem(int rawIndex, final ItemStack itemStack) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            this.player.drop(itemStack, true);
+            return;
+        }
+
+        indexedCompartment.compartment().set(indexedCompartment.index(), itemStack);
+    }
+
+    @Override
+    public float getDestroySpeed(BlockState blockState) {
+        return this.items.get(this.selected).getDestroySpeed(blockState);
+    }
+
+    @Override
+    public ListTag save(ListTag listTag) {
+        for (int i = 0; i < this.items.size(); ++i) {
+            if (!this.items.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)i);
+                this.items.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        for (int i = 0; i < this.armor.size(); ++i) {
+            if (!this.armor.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)(i + 100));
+                this.armor.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        for (int i = 0; i < this.offhand.size(); ++i) {
+            if (!this.offhand.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)(i + 150));
+                this.offhand.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        return listTag;
+    }
+
+    @Override
+    public void load(ListTag listTag) {
+        this.items.clear();
+        this.armor.clear();
+        this.offhand.clear();
+
+        for(int i = 0; i < listTag.size(); ++i) {
+            CompoundTag compoundTag = listTag.getCompound(i);
+            int j = compoundTag.getByte("Slot") & 255;
+            ItemStack itemstack = ItemStack.of(compoundTag);
+            if (!itemstack.isEmpty()) {
+                if (j < this.items.size()) {
+                    this.items.set(j, itemstack);
+                } else if (j >= 100 && j < this.armor.size() + 100) {
+                    this.armor.set(j - 100, itemstack);
+                } else if (j >= 150 && j < this.offhand.size() + 150) {
+                    this.offhand.set(j - 150, itemstack);
+                }
+            }
+        }
+
+    }
+
+    @Override
+    public int getContainerSize() {
+        return 45;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return !contains(itemStack -> !itemStack.isEmpty());
+    }
+
+    @Override
+    public ItemStack getItem(int rawIndex) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            return ItemStack.EMPTY;
+        }
+
+        return indexedCompartment.compartment().get(indexedCompartment.index());
+    }
+
+    @Override
+    public Component getName() {
+        return this.player.getName();
+    }
+
+    @Override
+    public ItemStack getArmor(int index) {
+        return this.armor.get(index);
+    }
+
+    @Override
+    public void hurtArmor(DamageSource damagesource, float damage, int[] armorIndices) {
+        if (damage > 0.0F) {
+            damage /= 4.0F;
+            if (damage < 1.0F) {
+                damage = 1.0F;
+            }
+
+            for (int index : armorIndices) {
+                ItemStack itemstack = this.armor.get(index);
+                if ((!damagesource.is(DamageTypeTags.IS_FIRE) || !itemstack.getItem().isFireResistant()) && itemstack.getItem() instanceof ArmorItem) {
+                    itemstack.hurtAndBreak((int) damage, this.player, localPlayer -> localPlayer.broadcastBreakEvent(EquipmentSlot.byTypeAndIndex(EquipmentSlot.Type.ARMOR, index)));
+                }
+            }
+        }
+    }
+
+    @Override
+    public void dropAll() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                ItemStack itemstack = compartment.get(i);
+                if (!itemstack.isEmpty()) {
+                    this.player.drop(itemstack, true, false);
+                    compartment.set(i, ItemStack.EMPTY);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void setChanged() {
+        super.setChanged();
+    }
+
+    @Override
+    public int getTimesChanged() {
+        return super.getTimesChanged();
+    }
+
+    @Override
+    public boolean stillValid(Player player) {
+        return true;
+    }
+
+    @Override
+    public boolean contains(ItemStack itemstack) {
+        return contains(itemStack -> itemStack.isEmpty() && itemStack.is(itemstack.getItem()));
+    }
+
+    @Override
+    public boolean contains(TagKey<Item> tagKey) {
+
+        return contains(itemStack -> !itemStack.isEmpty() && itemStack.is(tagKey));
+    }
+
+    @Override
+    public void replaceWith(Inventory inventory) {
+        Function<Integer, ItemStack> getter;
+
+        if (inventory instanceof SpecialPlayerInventory specialPlayerInventory) {
+            getter = specialPlayerInventory::getRawItem;
+        } else {
+            getter = inventory::getItem;
+        }
+
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            this.setRawItem(i, getter.apply(i));
+        }
+
+        this.selected = inventory.selected;
+    }
+
+    @Override
+    public void clearContent() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            compartment.clear();
+        }
+    }
+
+    @Override
+    public void fillStackedContents(StackedContents stackedContents) {
+        for (ItemStack itemstack : this.items) {
+            stackedContents.accountSimpleStack(itemstack);
+        }
+    }
+
+    @Override
+    public ItemStack removeFromSelected(boolean dropWholeStack) {
+        ItemStack itemstack = this.getSelected();
+        return itemstack.isEmpty() ? ItemStack.EMPTY : this.removeItem(this.selected, dropWholeStack ? itemstack.getCount() : 1);
+    }
+
+}
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R3;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IAnySilentContainer;
+import com.lishid.openinv.util.ReflectionHelper;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.level.ServerPlayerGameMode;
+import net.minecraft.world.MenuProvider;
+import net.minecraft.world.SimpleMenuProvider;
+import net.minecraft.world.entity.monster.Shulker;
+import net.minecraft.world.inventory.ChestMenu;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.inventory.PlayerEnderChestContainer;
+import net.minecraft.world.level.GameType;
+import net.minecraft.world.level.block.BarrelBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.ShulkerBoxBlock;
+import net.minecraft.world.level.block.TrappedChestBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.EnderChestBlockEntity;
+import net.minecraft.world.level.block.entity.RandomizableContainerBlockEntity;
+import net.minecraft.world.level.block.entity.ShulkerBoxBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.AABB;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.Statistic;
+import org.bukkit.block.ShulkerBox;
+import org.bukkit.craftbukkit.v1_20_R3.CraftWorld;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.util.logging.Logger;
+
+public class AnySilentContainer implements IAnySilentContainer {
+
+    private @Nullable Field serverPlayerGameModeGameType;
+
+    public AnySilentContainer() {
+        try {
+            try {
+                this.serverPlayerGameModeGameType = ServerPlayerGameMode.class.getDeclaredField("b");
+                this.serverPlayerGameModeGameType.setAccessible(true);
+            } catch (NoSuchFieldException e) {
+                Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
+                logger.warning("ServerPlayerGameMode#gameModeForPlayer's obfuscated name has changed!");
+                logger.warning("Please report this at https://github.com/Jikoo/OpenInv/issues");
+                logger.warning("Attempting to fall through using reflection. Please verify that SilentContainer does not fail.");
+                // N.B. gameModeForPlayer is (for now) declared before previousGameModeForPlayer so silent shouldn't break.
+                this.serverPlayerGameModeGameType = ReflectionHelper.grabFieldByType(ServerPlayerGameMode.class, GameType.class);
+            }
+        } catch (SecurityException e) {
+            Logger logger = OpenInv.getPlugin(OpenInv.class).getLogger();
+            logger.warning("Unable to directly write player game mode! SilentContainer will fail.");
+            logger.log(java.util.logging.Level.WARNING, "Error obtaining GameType field", e);
+        }
+    }
+
+    @Override
+    public boolean isShulkerBlocked(@NotNull ShulkerBox shulkerBox) {
+        org.bukkit.World bukkitWorld = shulkerBox.getWorld();
+        if (!(bukkitWorld instanceof CraftWorld)) {
+            bukkitWorld = Bukkit.getWorld(bukkitWorld.getUID());
+        }
+
+        if (!(bukkitWorld instanceof CraftWorld craftWorld)) {
+            Exception exception = new IllegalStateException("AnySilentContainer access attempted on an unknown world!");
+            OpenInv.getPlugin(OpenInv.class).getLogger().log(java.util.logging.Level.WARNING, exception.getMessage(), exception);
+            return false;
+        }
+
+        final ServerLevel world = craftWorld.getHandle();
+        final BlockPos blockPosition = new BlockPos(shulkerBox.getX(), shulkerBox.getY(), shulkerBox.getZ());
+        final BlockEntity tile = world.getBlockEntity(blockPosition);
+
+        if (!(tile instanceof ShulkerBoxBlockEntity shulkerBoxBlockEntity)
+                || shulkerBoxBlockEntity.getAnimationStatus() != ShulkerBoxBlockEntity.AnimationStatus.CLOSED) {
+            return false;
+        }
+
+        BlockState blockState = world.getBlockState(blockPosition);
+
+        // See net.minecraft.world.level.block.ShulkerBoxBlock#canOpen
+        AABB boundingBox = Shulker.getProgressDeltaAabb(blockState.getValue(ShulkerBoxBlock.FACING), 0.0F, 0.5F)
+                .move(blockPosition)
+                .deflate(1.0E-6D);
+        return !world.noCollision(boundingBox);
+    }
+
+    @Override
+    public boolean activateContainer(
+            @NotNull final Player bukkitPlayer,
+            final boolean silentchest,
+            @NotNull final org.bukkit.block.Block bukkitBlock) {
+
+        // Silent ender chest is API-only
+        if (silentchest && bukkitBlock.getType() == Material.ENDER_CHEST) {
+            bukkitPlayer.openInventory(bukkitPlayer.getEnderChest());
+            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
+            return true;
+        }
+
+        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+
+        final net.minecraft.world.level.Level level = player.level();
+        final BlockPos blockPos = new BlockPos(bukkitBlock.getX(), bukkitBlock.getY(), bukkitBlock.getZ());
+        final BlockEntity blockEntity = level.getBlockEntity(blockPos);
+
+        if (blockEntity == null) {
+            return false;
+        }
+
+        if (blockEntity instanceof EnderChestBlockEntity enderChestTile) {
+            // Anychest ender chest. See net.minecraft.world.level.block.EnderChestBlock
+            PlayerEnderChestContainer enderChest = player.getEnderChestInventory();
+            enderChest.setActiveChest(enderChestTile);
+            player.openMenu(new SimpleMenuProvider((containerCounter, playerInventory, ignored) -> {
+                MenuType<?> containers = PlayerDataManager.getContainers(enderChest.getContainerSize());
+                int rows = enderChest.getContainerSize() / 9;
+                return new ChestMenu(containers, containerCounter, playerInventory, enderChest, rows);
+            }, Component.translatable(("container.enderchest"))));
+            bukkitPlayer.incrementStatistic(Statistic.ENDERCHEST_OPENED);
+            return true;
+        }
+
+        if (!(blockEntity instanceof MenuProvider menuProvider)) {
+            return false;
+        }
+
+        BlockState blockState = level.getBlockState(blockPos);
+        Block block = blockState.getBlock();
+
+        if (block instanceof ChestBlock chestBlock) {
+
+            // boolean flag: do not check if chest is blocked
+            menuProvider = chestBlock.getMenuProvider(blockState, level, blockPos, true);
+
+            if (menuProvider == null) {
+                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
+                return false;
+            }
+
+            if (block instanceof TrappedChestBlock) {
+                bukkitPlayer.incrementStatistic(Statistic.TRAPPED_CHEST_TRIGGERED);
+            } else {
+                bukkitPlayer.incrementStatistic(Statistic.CHEST_OPENED);
+            }
+        }
+
+        if (block instanceof ShulkerBoxBlock) {
+            bukkitPlayer.incrementStatistic(Statistic.SHULKER_BOX_OPENED);
+        }
+
+        if (block instanceof BarrelBlock) {
+            bukkitPlayer.incrementStatistic(Statistic.OPEN_BARREL);
+        }
+
+        // AnyChest only - SilentChest not active, container unsupported, or unnecessary.
+        if (!silentchest || player.gameMode.getGameModeForPlayer() == GameType.SPECTATOR) {
+            player.openMenu(menuProvider);
+            return true;
+        }
+
+        // SilentChest requires access to setting players' game mode directly.
+        if (this.serverPlayerGameModeGameType == null) {
+            return false;
+        }
+
+        if (blockEntity instanceof RandomizableContainerBlockEntity lootable) {
+            if (lootable.lootTable != null) {
+                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
+                return false;
+            }
+        }
+
+        GameType gameType = player.gameMode.getGameModeForPlayer();
+        this.forceGameType(player, GameType.SPECTATOR);
+        player.openMenu(menuProvider);
+        this.forceGameType(player, gameType);
+        return true;
+    }
+
+    @Override
+    public void deactivateContainer(@NotNull final Player bukkitPlayer) {
+        if (this.serverPlayerGameModeGameType == null || bukkitPlayer.getGameMode() == GameMode.SPECTATOR) {
+            return;
+        }
+
+        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+
+        // Force game mode change without informing plugins or players.
+        // Regular game mode set calls GameModeChangeEvent and is cancellable.
+        GameType gameType = player.gameMode.getGameModeForPlayer();
+        this.forceGameType(player, GameType.SPECTATOR);
+
+        // ServerPlayer#closeContainer cannot be called without entering an
+        // infinite loop because this method is called during inventory close.
+        // From ServerPlayer#closeContainer -> CraftEventFactory#handleInventoryCloseEvent
+        player.containerMenu.transferTo(player.inventoryMenu, player.getBukkitEntity());
+        // From ServerPlayer#closeContainer
+        player.doCloseContainer();
+        // Regular inventory close will handle the rest - packet sending, etc.
+
+        // Revert forced game mode.
+        this.forceGameType(player, gameType);
+    }
+
+    private void forceGameType(final ServerPlayer player, final GameType gameMode) {
+        if (this.serverPlayerGameModeGameType == null) {
+            // No need to warn repeatedly, error on startup and lack of function should be enough.
+            return;
+        }
+        try {
+            this.serverPlayerGameModeGameType.setAccessible(true);
+            this.serverPlayerGameModeGameType.set(player.gameMode, gameMode);
+        } catch (IllegalArgumentException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+}
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R3;
+
+import com.mojang.logging.LogUtils;
+import net.minecraft.Util;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtIo;
+import net.minecraft.nbt.NumericTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.storage.PlayerDataStorage;
+import org.bukkit.craftbukkit.v1_20_R3.CraftServer;
+import org.bukkit.craftbukkit.v1_20_R3.entity.CraftPlayer;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Set;
+
+public class OpenPlayer extends CraftPlayer {
+
+    private static final Set<String> RESET_TAGS = Set.of(
+        // net.minecraft.world.Entity#saveWithoutId(CompoundTag)
+        "CustomName",
+        "CustomNameVisible",
+        "Silent",
+        "NoGravity",
+        "Glowing",
+        "TicksFrozen",
+        "HasVisualFire",
+        "Tags",
+        "Passengers",
+        // net.minecraft.server.level.ServerPlayer#addAdditionalSaveData(CompoundTag)
+        // Intentional omissions to prevent mount loss: Attach, Entity, and RootVehicle
+        "warden_spawn_tracker",
+        "enteredNetherPosition",
+        "SpawnX",
+        "SpawnY",
+        "SpawnZ",
+        "SpawnForced",
+        "SpawnAngle",
+        "SpawnDimension",
+        // net.minecraft.world.entity.player.Player#addAdditionalSaveData(CompoundTag)
+        "ShoulderEntityLeft",
+        "ShoulderEntityRight",
+        "LastDeathLocation",
+        // net.minecraft.world.entity.LivingEntity#addAdditionalSaveData(CompoundTag)
+        "ActiveEffects", // Backwards compat: Renamed from 1.19
+        "active_effects",
+        "SleepingX",
+        "SleepingY",
+        "SleepingZ",
+        "Brain"
+    );
+
+    public OpenPlayer(CraftServer server, ServerPlayer entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public void loadData() {
+        PlayerDataManager.loadData(getHandle());
+    }
+
+    @Override
+    public void saveData() {
+        ServerPlayer player = this.getHandle();
+        // See net.minecraft.world.level.storage.PlayerDataStorage#save(EntityHuman)
+        try {
+            PlayerDataStorage worldNBTStorage = player.server.getPlayerList().playerIo;
+
+            CompoundTag oldData = isOnline() ? null : worldNBTStorage.load(player);
+            CompoundTag playerData = getWritableTag(oldData);
+            playerData = player.saveWithoutId(playerData);
+            setExtraData(playerData);
+
+            if (oldData != null) {
+                // Revert certain special data values when offline.
+                revertSpecialValues(playerData, oldData);
+            }
+
+            Path playerDataDir = worldNBTStorage.getPlayerDir().toPath();
+            Path file = Files.createTempFile(playerDataDir, player.getStringUUID() + "-", ".dat");
+            NbtIo.writeCompressed(playerData, file);
+            Path dataFile = playerDataDir.resolve(player.getStringUUID() + ".dat");
+            Path backupFile = playerDataDir.resolve(player.getStringUUID() + ".dat_old");
+            Util.safeReplaceFile(dataFile, file, backupFile);
+        } catch (Exception e) {
+            LogUtils.getLogger().warn("Failed to save player data for {}: {}", player.getScoreboardName(), e);
+        }
+    }
+
+    @Contract("null -> new")
+    private @NotNull CompoundTag getWritableTag(@Nullable CompoundTag oldData) {
+        if (oldData == null) {
+            return new CompoundTag();
+        }
+
+        // Copy old data. This is a deep clone, so operating on it should be safe.
+        oldData = oldData.copy();
+
+        // Remove vanilla/server data that is not written every time.
+        oldData.getAllKeys()
+            .removeIf(key -> RESET_TAGS.contains(key) || key.startsWith("Bukkit"));
+
+        return oldData;
+    }
+
+    private void revertSpecialValues(@NotNull CompoundTag newData, @NotNull CompoundTag oldData) {
+        // Revert automatic updates to play timestamps.
+        copyValue(oldData, newData, "bukkit", "lastPlayed", NumericTag.class);
+        copyValue(oldData, newData, "Paper", "LastSeen", NumericTag.class);
+        copyValue(oldData, newData, "Paper", "LastLogin", NumericTag.class);
+    }
+
+    private <T extends Tag> void copyValue(
+        @NotNull CompoundTag source,
+        @NotNull CompoundTag target,
+        @NotNull String container,
+        @NotNull String key,
+        @NotNull Class<T> tagType) {
+        CompoundTag oldContainer = getTag(source, container, CompoundTag.class);
+        CompoundTag newContainer = getTag(target, container, CompoundTag.class);
+
+        // New container being null means the server implementation doesn't store this data.
+        if (newContainer == null) {
+            return;
+        }
+
+        // If old tag exists, copy it to new location, removing otherwise.
+        setTag(newContainer, key, getTag(oldContainer, key, tagType));
+    }
+
+    private <T extends Tag> @Nullable T getTag(
+        @Nullable CompoundTag container,
+        @NotNull String key,
+        @NotNull Class<T> dataType) {
+        if (container == null) {
+            return null;
+        }
+        Tag value = container.get(key);
+        if (value == null || !dataType.isAssignableFrom(value.getClass())) {
+            return null;
+        }
+        return dataType.cast(value);
+    }
+
+    private <T extends Tag> void setTag(
+        @NotNull CompoundTag container,
+        @NotNull String key,
+        @Nullable T data) {
+        if (data == null) {
+            container.remove(key);
+        } else {
+            container.put(key, data);
+        }
+    }
+
+}
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R3;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IPlayerDataManager;
+import com.lishid.openinv.internal.ISpecialInventory;
+import com.lishid.openinv.internal.OpenInventoryView;
+import com.mojang.authlib.GameProfile;
+import com.mojang.serialization.Dynamic;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtOps;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ClientInformation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.ChatVisiblity;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.dimension.DimensionType;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_20_R3.CraftServer;
+import org.bukkit.craftbukkit.v1_20_R3.CraftWorld;
+import org.bukkit.craftbukkit.v1_20_R3.entity.CraftPlayer;
+import org.bukkit.craftbukkit.v1_20_R3.event.CraftEventFactory;
+import org.bukkit.craftbukkit.v1_20_R3.inventory.CraftContainer;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+public class PlayerDataManager implements IPlayerDataManager {
+
+    private static boolean paper;
+
+    static {
+        try {
+            Class.forName("io.papermc.paper.configuration.Configuration");
+            paper = true;
+        } catch (ClassNotFoundException ignored) {
+            paper = false;
+        }
+    }
+
+    private @Nullable Field bukkitEntity;
+
+    public PlayerDataManager() {
+        try {
+            bukkitEntity = Entity.class.getDeclaredField("bukkitEntity");
+        } catch (NoSuchFieldException e) {
+            Logger logger = JavaPlugin.getPlugin(OpenInv.class).getLogger();
+            logger.warning("Unable to obtain field to inject custom save process - certain player data may be lost when saving!");
+            logger.log(java.util.logging.Level.WARNING, e.getMessage(), e);
+            bukkitEntity = null;
+        }
+    }
+
+    public static @NotNull ServerPlayer getHandle(final Player player) {
+        if (player instanceof CraftPlayer) {
+            return ((CraftPlayer) player).getHandle();
+        }
+
+        Server server = player.getServer();
+        ServerPlayer nmsPlayer = null;
+
+        if (server instanceof CraftServer) {
+            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getUniqueId());
+        }
+
+        if (nmsPlayer == null) {
+            // Could use reflection to examine fields, but it's honestly not worth the bother.
+            throw new RuntimeException("Unable to fetch EntityPlayer from Player implementation " + player.getClass().getName());
+        }
+
+        return nmsPlayer;
+    }
+
+    @Override
+    public @Nullable Player loadPlayer(@NotNull final OfflinePlayer offline) {
+        // Ensure player has data
+        if (!offline.hasPlayedBefore()) {
+            return null;
+        }
+
+        MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
+        ServerLevel worldServer = server.getLevel(Level.OVERWORLD);
+
+        if (worldServer == null) {
+            return null;
+        }
+
+        // Create a new ServerPlayer.
+        ServerPlayer entity = createNewPlayer(server, worldServer, offline);
+
+        // Stop listening for advancement progression - if this is not cleaned up, loading causes a memory leak.
+        entity.getAdvancements().stopListening();
+
+        // Try to load the player's data.
+        if (loadData(entity)) {
+            // If data is loaded successfully, return the Bukkit entity.
+            return entity.getBukkitEntity();
+        }
+
+        return null;
+    }
+
+    private @NotNull ServerPlayer createNewPlayer(
+        @NotNull MinecraftServer server,
+        @NotNull ServerLevel worldServer,
+        @NotNull final OfflinePlayer offline) {
+        // See net.minecraft.server.players.PlayerList#canPlayerLogin(ServerLoginPacketListenerImpl, GameProfile)
+        // See net.minecraft.server.network.ServerLoginPacketListenerImpl#handleHello(ServerboundHelloPacket)
+        GameProfile profile = new GameProfile(offline.getUniqueId(),
+            offline.getName() != null ? offline.getName() : offline.getUniqueId().toString());
+
+        ClientInformation dummyInfo = new ClientInformation(
+            "en_us",
+            1, // Reduce distance just in case.
+            ChatVisiblity.HIDDEN, // Don't accept chat.
+            false,
+            ServerPlayer.DEFAULT_MODEL_CUSTOMIZATION,
+            ServerPlayer.DEFAULT_MAIN_HAND,
+            true,
+            false // Don't list in player list (not that this player is in the list anyway).
+        );
+
+        ServerPlayer entity = new ServerPlayer(server, worldServer, profile, dummyInfo);
+
+        try {
+            injectPlayer(entity);
+        } catch (IllegalAccessException e) {
+            JavaPlugin.getPlugin(OpenInv.class).getLogger().log(
+                java.util.logging.Level.WARNING,
+                e,
+                () -> "Unable to inject ServerPlayer, certain player data may be lost when saving!");
+        }
+
+        return entity;
+    }
+
+    static boolean loadData(@NotNull ServerPlayer player) {
+        // See CraftPlayer#loadData
+        CompoundTag loadedData = player.server.getPlayerList().playerIo.load(player);
+
+        if (loadedData == null) {
+            // Exceptions with loading are logged by Mojang.
+            return false;
+        }
+
+        // Read basic data into the player.
+        player.load(loadedData);
+        // Also read "extra" data.
+        player.readAdditionalSaveData(loadedData);
+        // Game type settings are also loaded separately.
+        player.loadGameTypes(loadedData);
+
+        if (paper) {
+            // Paper: world is not loaded by ServerPlayer#load(CompoundTag).
+            parseWorld(player, loadedData);
+        }
+
+        return true;
+    }
+
+    private static void parseWorld(@NotNull ServerPlayer player, @NotNull CompoundTag loadedData) {
+        // See PlayerList#placeNewPlayer
+        World bukkitWorld;
+        if (loadedData.contains("WorldUUIDMost") && loadedData.contains("WorldUUIDLeast")) {
+            // Modern Bukkit world.
+            bukkitWorld = Bukkit.getServer().getWorld(new UUID(loadedData.getLong("WorldUUIDMost"), loadedData.getLong("WorldUUIDLeast")));
+        } else if (loadedData.contains("world", net.minecraft.nbt.Tag.TAG_STRING)) {
+            // Legacy Bukkit world.
+            bukkitWorld = Bukkit.getServer().getWorld(loadedData.getString("world"));
+        } else {
+            // Vanilla player data.
+            DimensionType.parseLegacy(new Dynamic<>(NbtOps.INSTANCE, loadedData.get("Dimension")))
+                .resultOrPartial(JavaPlugin.getPlugin(OpenInv.class).getLogger()::warning)
+                .map(player.server::getLevel)
+                // If ServerLevel exists, set, otherwise move to spawn.
+                .ifPresentOrElse(player::setServerLevel, () -> player.spawnIn(null));
+            return;
+        }
+        if (bukkitWorld == null) {
+            player.spawnIn(null);
+            return;
+        }
+        player.setServerLevel(((CraftWorld) bukkitWorld).getHandle());
+    }
+
+    private void injectPlayer(ServerPlayer player) throws IllegalAccessException {
+        if (bukkitEntity == null) {
+            return;
+        }
+
+        bukkitEntity.setAccessible(true);
+
+        bukkitEntity.set(player, new OpenPlayer(player.server.server, player));
+    }
+
+    @Override
+    public @NotNull Player inject(@NotNull Player player) {
+        try {
+            ServerPlayer nmsPlayer = getHandle(player);
+            if (nmsPlayer.getBukkitEntity() instanceof OpenPlayer openPlayer) {
+                return openPlayer;
+            }
+            injectPlayer(nmsPlayer);
+            return nmsPlayer.getBukkitEntity();
+        } catch (IllegalAccessException e) {
+            JavaPlugin.getPlugin(OpenInv.class).getLogger().log(
+                java.util.logging.Level.WARNING,
+                e,
+                () -> "Unable to inject ServerPlayer, certain player data may be lost when saving!");
+            return player;
+        }
+    }
+
+    @Override
+    public @Nullable InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {
+
+        ServerPlayer nmsPlayer = getHandle(player);
+
+        if (nmsPlayer.connection == null) {
+            return null;
+        }
+
+        InventoryView view = getView(player, inventory);
+
+        if (view == null) {
+            return player.openInventory(inventory.getBukkitInventory());
+        }
+
+        AbstractContainerMenu container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
+            @Override
+            public MenuType<?> getType() {
+                return getContainers(inventory.getBukkitInventory().getSize());
+            }
+        };
+
+        container.setTitle(Component.literal(view.getTitle()));
+        container = CraftEventFactory.callInventoryOpenEvent(nmsPlayer, container);
+
+        if (container == null) {
+            return null;
+        }
+
+        nmsPlayer.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(),
+                Component.literal(container.getBukkitView().getTitle())));
+        nmsPlayer.containerMenu = container;
+        nmsPlayer.initMenu(container);
+
+        return container.getBukkitView();
+
+    }
+
+    private @Nullable InventoryView getView(Player player, ISpecialInventory inventory) {
+        if (inventory instanceof SpecialEnderChest) {
+            return new OpenInventoryView(player, inventory, "container.enderchest", "'s Ender Chest");
+        } else if (inventory instanceof SpecialPlayerInventory) {
+            return new OpenInventoryView(player, inventory, "container.player", "'s Inventory");
+        } else {
+            return null;
+        }
+    }
+
+    static @NotNull MenuType<?> getContainers(int inventorySize) {
+
+        return switch (inventorySize) {
+            case 9 -> MenuType.GENERIC_9x1;
+            case 18 -> MenuType.GENERIC_9x2;
+            case 36 -> MenuType.GENERIC_9x4; // PLAYER
+            case 41, 45 -> MenuType.GENERIC_9x5;
+            case 54 -> MenuType.GENERIC_9x6;
+            default -> MenuType.GENERIC_9x3; // Default 27-slot inventory
+        };
+    }
+
+    @Override
+    public int convertToPlayerSlot(InventoryView view, int rawSlot) {
+        int topSize = view.getTopInventory().getSize();
+        if (topSize <= rawSlot) {
+            // Slot is not inside special inventory, use Bukkit logic.
+            return view.convertSlot(rawSlot);
+        }
+
+        // Main inventory, slots 0-26 -> 9-35
+        if (rawSlot < 27) {
+            return rawSlot + 9;
+        }
+        // Hotbar, slots 27-35 -> 0-8
+        if (rawSlot < 36) {
+            return rawSlot - 27;
+        }
+        // Armor, slots 36-39 -> 39-36
+        if (rawSlot < 40) {
+            return 36 + (39 - rawSlot);
+        }
+        // Off hand
+        if (rawSlot == 40) {
+            return 40;
+        }
+        // Drop slots, "out of inventory"
+        return -1;
+    }
+
+}
@@ -0,0 +1,351 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R3;
+
+import com.lishid.openinv.internal.ISpecialEnderChest;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.ContainerListener;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.player.StackedContents;
+import net.minecraft.world.inventory.PlayerEnderChestContainer;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.entity.EnderChestBlockEntity;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_20_R3.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_20_R3.inventory.CraftInventory;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpecialEnderChest {
+
+    private final CraftInventory inventory;
+    private ServerPlayer owner;
+    private NonNullList<ItemStack> items;
+    private boolean playerOnline;
+
+    public SpecialEnderChest(final org.bukkit.entity.Player player, final Boolean online) {
+        super(PlayerDataManager.getHandle(player));
+        this.inventory = new CraftInventory(this);
+        this.owner = PlayerDataManager.getHandle(player);
+        this.playerOnline = online;
+        this.items = this.owner.getEnderChestInventory().items;
+    }
+
+    @Override
+    public @NotNull CraftInventory getBukkitInventory() {
+        return inventory;
+    }
+
+    @Override
+    public void setPlayerOffline() {
+        this.playerOnline = false;
+    }
+
+    @Override
+    public void setPlayerOnline(@NotNull final org.bukkit.entity.Player player) {
+        if (this.playerOnline) {
+            return;
+        }
+
+        ServerPlayer offlinePlayer = this.owner;
+        ServerPlayer onlinePlayer = PlayerDataManager.getHandle(player);
+
+        // Set owner to new player.
+        this.owner = onlinePlayer;
+
+        // Set player's ender chest contents to our modified contents.
+        PlayerEnderChestContainer onlineEnderChest = onlinePlayer.getEnderChestInventory();
+        for (int i = 0; i < onlineEnderChest.getContainerSize(); ++i) {
+            onlineEnderChest.setItem(i, this.items.get(i));
+        }
+
+        // Set our item array to the new inventory's array.
+        this.items = onlineEnderChest.items;
+
+        // Add viewers to new inventory.
+        onlineEnderChest.transaction.addAll(offlinePlayer.getEnderChestInventory().transaction);
+
+        this.playerOnline = true;
+    }
+
+    @Override
+    public @NotNull org.bukkit.entity.Player getPlayer() {
+        return owner.getBukkitEntity();
+    }
+
+    @Override
+    public void setChanged() {
+        this.owner.getEnderChestInventory().setChanged();
+    }
+
+    @Override
+    public List<ItemStack> getContents() {
+        return this.items;
+    }
+
+    @Override
+    public void onOpen(CraftHumanEntity who) {
+        this.owner.getEnderChestInventory().onOpen(who);
+    }
+
+    @Override
+    public void onClose(CraftHumanEntity who) {
+        this.owner.getEnderChestInventory().onClose(who);
+    }
+
+    @Override
+    public List<HumanEntity> getViewers() {
+        return this.owner.getEnderChestInventory().getViewers();
+    }
+
+    @Override
+    public boolean stillValid(Player player) {
+        return true;
+    }
+
+    @Override
+    public void setActiveChest(EnderChestBlockEntity enderChest) {
+        this.owner.getEnderChestInventory().setActiveChest(enderChest);
+    }
+
+    @Override
+    public boolean isActiveChest(EnderChestBlockEntity enderChest) {
+        return this.owner.getEnderChestInventory().isActiveChest(enderChest);
+    }
+
+    @Override
+    public int getMaxStackSize() {
+        return this.owner.getEnderChestInventory().getMaxStackSize();
+    }
+
+    @Override
+    public void setMaxStackSize(int i) {
+        this.owner.getEnderChestInventory().setMaxStackSize(i);
+    }
+
+    @Override
+    public InventoryHolder getOwner() {
+        return this.owner.getEnderChestInventory().getOwner();
+    }
+
+    @Override
+    public @Nullable Location getLocation() {
+        return null;
+    }
+
+    @Override
+    public void addListener(ContainerListener listener) {
+        this.owner.getEnderChestInventory().addListener(listener);
+    }
+
+    @Override
+    public void removeListener(ContainerListener listener) {
+        this.owner.getEnderChestInventory().removeListener(listener);
+    }
+
+    @Override
+    public ItemStack getItem(int i) {
+        return i >= 0 && i < this.items.size() ? this.items.get(i) : ItemStack.EMPTY;
+    }
+
+    @Override
+    public ItemStack removeItem(int i, int j) {
+        ItemStack itemstack = ContainerHelper.removeItem(this.items, i, j);
+        if (!itemstack.isEmpty()) {
+            this.setChanged();
+        }
+
+        return itemstack;
+    }
+
+    @Override
+    public ItemStack addItem(ItemStack itemstack) {
+        ItemStack localItem = itemstack.copy();
+        this.moveItemToOccupiedSlotsWithSameType(localItem);
+        if (localItem.isEmpty()) {
+            return ItemStack.EMPTY;
+        } else {
+            this.moveItemToEmptySlots(localItem);
+            return localItem.isEmpty() ? ItemStack.EMPTY : localItem;
+        }
+    }
+
+    @Override
+    public boolean canAddItem(ItemStack itemstack) {
+        for (ItemStack itemstack1 : this.items) {
+            if (itemstack1.isEmpty() || ItemStack.isSameItemSameTags(itemstack1, itemstack) && itemstack1.getCount() < itemstack1.getMaxStackSize()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private void moveItemToEmptySlots(ItemStack itemstack) {
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            ItemStack localItem = this.getItem(i);
+            if (localItem.isEmpty()) {
+                this.setItem(i, itemstack.copy());
+                itemstack.setCount(0);
+                return;
+            }
+        }
+    }
+
+    private void moveItemToOccupiedSlotsWithSameType(ItemStack itemstack) {
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            ItemStack localItem = this.getItem(i);
+            if (ItemStack.isSameItemSameTags(localItem, itemstack)) {
+                this.moveItemsBetweenStacks(itemstack, localItem);
+                if (itemstack.isEmpty()) {
+                    return;
+                }
+            }
+        }
+    }
+
+    private void moveItemsBetweenStacks(ItemStack itemstack, ItemStack itemstack1) {
+        int i = Math.min(this.getMaxStackSize(), itemstack1.getMaxStackSize());
+        int j = Math.min(itemstack.getCount(), i - itemstack1.getCount());
+        if (j > 0) {
+            itemstack1.grow(j);
+            itemstack.shrink(j);
+            this.setChanged();
+        }
+    }
+
+    @Override
+    public ItemStack removeItemNoUpdate(int i) {
+        ItemStack itemstack = this.items.get(i);
+        if (itemstack.isEmpty()) {
+            return ItemStack.EMPTY;
+        } else {
+            this.items.set(i, ItemStack.EMPTY);
+            return itemstack;
+        }
+    }
+
+    @Override
+    public void setItem(int i, ItemStack itemstack) {
+        this.items.set(i, itemstack);
+        if (!itemstack.isEmpty() && itemstack.getCount() > this.getMaxStackSize()) {
+            itemstack.setCount(this.getMaxStackSize());
+        }
+
+        this.setChanged();
+    }
+
+    @Override
+    public int getContainerSize() {
+        return this.owner.getEnderChestInventory().getContainerSize();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.items.stream().allMatch(ItemStack::isEmpty);
+    }
+
+    @Override
+    public void startOpen(Player player) {
+    }
+
+    @Override
+    public void stopOpen(Player player) {
+    }
+
+    @Override
+    public boolean canPlaceItem(int i, ItemStack itemstack) {
+        return true;
+    }
+
+    @Override
+    public void clearContent() {
+        this.items.clear();
+        this.setChanged();
+    }
+
+    @Override
+    public void fillStackedContents(StackedContents stackedContents) {
+        for (ItemStack itemstack : this.items) {
+            stackedContents.accountStack(itemstack);
+        }
+
+    }
+
+    @Override
+    public List<ItemStack> removeAllItems() {
+        List<ItemStack> list = this.items.stream().filter(Predicate.not(ItemStack::isEmpty)).collect(Collectors.toList());
+        this.clearContent();
+        return list;
+    }
+
+    @Override
+    public ItemStack removeItemType(Item item, int i) {
+        ItemStack itemstack = new ItemStack(item, 0);
+
+        for(int j = this.getContainerSize() - 1; j >= 0; --j) {
+            ItemStack localItem = this.getItem(j);
+            if (localItem.getItem().equals(item)) {
+                int k = i - itemstack.getCount();
+                ItemStack splitItem = localItem.split(k);
+                itemstack.grow(splitItem.getCount());
+                if (itemstack.getCount() == i) {
+                    break;
+                }
+            }
+        }
+
+        if (!itemstack.isEmpty()) {
+            this.setChanged();
+        }
+
+        return itemstack;
+    }
+
+    @Override
+    public String toString() {
+        return this.items.stream().filter((itemStack) -> !itemStack.isEmpty()).toList().toString();
+    }
+
+    @Override
+    public void fromTag(ListTag listTag) {
+        for (int i = 0; i < this.getContainerSize(); ++i) {
+            this.setItem(i, ItemStack.EMPTY);
+        }
+
+        for (int i = 0; i < listTag.size(); ++i) {
+            CompoundTag compoundTag = listTag.getCompound(i);
+            int j = compoundTag.getByte("Slot") & 255;
+            if (j < this.getContainerSize()) {
+                this.setItem(j, ItemStack.of(compoundTag));
+            }
+        }
+
+    }
+
+}
@@ -0,0 +1,807 @@
+/*
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_20_R3;
+
+import com.google.common.collect.ImmutableList;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
+import net.minecraft.CrashReport;
+import net.minecraft.CrashReportCategory;
+import net.minecraft.ReportedException;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.tags.DamageTypeTags;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.Container;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.player.StackedContents;
+import net.minecraft.world.item.ArmorItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.state.BlockState;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.v1_20_R3.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_20_R3.inventory.CraftInventory;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class SpecialPlayerInventory extends Inventory implements ISpecialPlayerInventory {
+
+    private final CraftInventory inventory;
+    private boolean playerOnline;
+    private Player player;
+    private NonNullList<ItemStack> items;
+    private NonNullList<ItemStack> armor;
+    private NonNullList<ItemStack> offhand;
+    private List<NonNullList<ItemStack>> compartments;
+
+    public SpecialPlayerInventory(@NotNull org.bukkit.entity.Player bukkitPlayer, @NotNull Boolean online) {
+        super(PlayerDataManager.getHandle(bukkitPlayer));
+        this.inventory = new CraftInventory(this);
+        this.playerOnline = online;
+        this.player = super.player;
+        this.selected = player.getInventory().selected;
+        this.items = this.player.getInventory().items;
+        this.armor = this.player.getInventory().armor;
+        this.offhand = this.player.getInventory().offhand;
+        this.compartments = ImmutableList.of(this.items, this.armor, this.offhand);
+    }
+
+    @Override
+    public void setPlayerOnline(@NotNull org.bukkit.entity.Player player) {
+        if (this.playerOnline) {
+            return;
+        }
+
+        Player offlinePlayer = this.player;
+        Player onlinePlayer = PlayerDataManager.getHandle(player);
+        onlinePlayer.getInventory().transaction.addAll(this.transaction);
+
+        // Set owner to new player.
+        this.player = onlinePlayer;
+
+        // Set player's inventory contents to our modified contents.
+        Inventory onlineInventory = onlinePlayer.getInventory();
+        for (int i = 0; i < getContainerSize(); ++i) {
+            onlineInventory.setItem(i, getRawItem(i));
+        }
+        onlineInventory.selected = this.selected;
+
+        // Set our item arrays to the new inventory's arrays.
+        this.items = onlineInventory.items;
+        this.armor = onlineInventory.armor;
+        this.offhand = onlineInventory.offhand;
+        this.compartments = ImmutableList.of(this.items, this.armor, this.offhand);
+
+        // Add existing viewers to new viewer list.
+        Inventory offlineInventory = offlinePlayer.getInventory();
+        // Remove self from listing - player is always a viewer of their own inventory, prevent duplicates.
+        offlineInventory.transaction.remove(offlinePlayer.getBukkitEntity());
+        onlineInventory.transaction.addAll(offlineInventory.transaction);
+
+        this.playerOnline = true;
+    }
+
+    @Override
+    public @NotNull CraftInventory getBukkitInventory() {
+        return this.inventory;
+    }
+
+    @Override
+    public void setPlayerOffline() {
+        this.playerOnline = false;
+    }
+
+    @Override
+    public @NotNull HumanEntity getPlayer() {
+        return this.player.getBukkitEntity();
+    }
+
+    private @NotNull ItemStack getRawItem(int i) {
+        if (i < 0) {
+            return ItemStack.EMPTY;
+        }
+
+        NonNullList<ItemStack> list;
+        for (Iterator<NonNullList<ItemStack>> iterator = this.compartments.iterator(); iterator.hasNext(); i -= list.size()) {
+            list = iterator.next();
+            if (i < list.size()) {
+                return list.get(i);
+            }
+        }
+
+        return ItemStack.EMPTY;
+    }
+
+    private void setRawItem(int i, @NotNull ItemStack itemStack) {
+        if (i < 0) {
+            return;
+        }
+
+        NonNullList<ItemStack> list;
+        for (Iterator<NonNullList<ItemStack>> iterator = this.compartments.iterator(); iterator.hasNext(); i -= list.size()) {
+            list = iterator.next();
+            if (i < list.size()) {
+                list.set(i, itemStack);
+            }
+        }
+    }
+
+    private record IndexedCompartment(@Nullable NonNullList<ItemStack> compartment, int index) {}
+
+    private @NotNull SpecialPlayerInventory.IndexedCompartment getIndexedContent(int index) {
+        if (index < items.size()) {
+            return new IndexedCompartment(items, getReversedItemSlotNum(index));
+        }
+
+        index -= items.size();
+
+        if (index < armor.size()) {
+            return new IndexedCompartment(armor, getReversedArmorSlotNum(index));
+        }
+
+        index -= armor.size();
+
+        if (index < offhand.size()) {
+            return new IndexedCompartment(offhand, index);
+        }
+
+        index -= offhand.size();
+
+        return new IndexedCompartment(null, index);
+    }
+
+    private int getReversedArmorSlotNum(final int i) {
+        if (i == 0) {
+            return 3;
+        }
+        if (i == 1) {
+            return 2;
+        }
+        if (i == 2) {
+            return 1;
+        }
+        if (i == 3) {
+            return 0;
+        }
+        return i;
+    }
+
+    private int getReversedItemSlotNum(final int i) {
+        if (i >= 27) {
+            return i - 27;
+        }
+        return i + 9;
+    }
+
+    private boolean contains(Predicate<ItemStack> predicate) {
+        return this.compartments.stream().flatMap(NonNullList::stream).anyMatch(predicate);
+    }
+
+    @Override
+    public List<ItemStack> getArmorContents() {
+        return this.armor;
+    }
+
+    @Override
+    public void onOpen(CraftHumanEntity who) {
+        this.player.getInventory().onOpen(who);
+    }
+
+    @Override
+    public void onClose(CraftHumanEntity who) {
+        this.player.getInventory().onClose(who);
+    }
+
+    @Override
+    public List<HumanEntity> getViewers() {
+        return this.player.getInventory().getViewers();
+    }
+
+    @Override
+    public InventoryHolder getOwner() {
+        return this.player.getBukkitEntity();
+    }
+
+    @Override
+    public int getMaxStackSize() {
+        return this.player.getInventory().getMaxStackSize();
+    }
+
+    @Override
+    public void setMaxStackSize(int size) {
+        this.player.getInventory().setMaxStackSize(size);
+    }
+
+    @Override
+    public Location getLocation() {
+        return this.player.getBukkitEntity().getLocation();
+    }
+
+    @Override
+    public boolean hasCustomName() {
+        return false;
+    }
+
+    @Override
+    public List<ItemStack> getContents() {
+        return this.compartments.stream().flatMap(Collection::stream).collect(Collectors.toList());
+    }
+
+    @Override
+    public ItemStack getSelected() {
+        return isHotbarSlot(this.selected) ? this.items.get(this.selected) : ItemStack.EMPTY;
+    }
+
+    private boolean hasRemainingSpaceForItem(ItemStack itemstack, ItemStack itemstack1) {
+        return !itemstack.isEmpty() && ItemStack.isSameItemSameTags(itemstack, itemstack1) && itemstack.isStackable() && itemstack.getCount() < itemstack.getMaxStackSize() && itemstack.getCount() < this.getMaxStackSize();
+    }
+
+    @Override
+    public int canHold(ItemStack itemstack) {
+        int remains = itemstack.getCount();
+
+        for (int i = 0; i < this.items.size(); ++i) {
+            ItemStack itemstack1 = this.getRawItem(i);
+            if (itemstack1.isEmpty()) {
+                return itemstack.getCount();
+            }
+
+            if (this.hasRemainingSpaceForItem(itemstack1, itemstack)) {
+                remains -= (itemstack1.getMaxStackSize() < this.getMaxStackSize() ? itemstack1.getMaxStackSize() : this.getMaxStackSize()) - itemstack1.getCount();
+            }
+
+            if (remains <= 0) {
+                return itemstack.getCount();
+            }
+        }
+
+        ItemStack offhandItemStack = this.getRawItem(this.items.size() + this.armor.size());
+        if (this.hasRemainingSpaceForItem(offhandItemStack, itemstack)) {
+            remains -= (offhandItemStack.getMaxStackSize() < this.getMaxStackSize() ? offhandItemStack.getMaxStackSize() : this.getMaxStackSize()) - offhandItemStack.getCount();
+        }
+
+        return remains <= 0 ? itemstack.getCount() : itemstack.getCount() - remains;
+    }
+
+    @Override
+    public int getFreeSlot() {
+        for(int i = 0; i < this.items.size(); ++i) {
+            if (this.items.get(i).isEmpty()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public void setPickedItem(ItemStack itemstack) {
+        int i = this.findSlotMatchingItem(itemstack);
+        if (isHotbarSlot(i)) {
+            this.selected = i;
+        } else if (i == -1) {
+            this.selected = this.getSuitableHotbarSlot();
+            if (!this.items.get(this.selected).isEmpty()) {
+                int j = this.getFreeSlot();
+                if (j != -1) {
+                    this.items.set(j, this.items.get(this.selected));
+                }
+            }
+
+            this.items.set(this.selected, itemstack);
+        } else {
+            this.pickSlot(i);
+        }
+
+    }
+
+    @Override
+    public void pickSlot(int i) {
+        this.selected = this.getSuitableHotbarSlot();
+        ItemStack itemstack = this.items.get(this.selected);
+        this.items.set(this.selected, this.items.get(i));
+        this.items.set(i, itemstack);
+    }
+
+    @Override
+    public int findSlotMatchingItem(ItemStack itemstack) {
+        for(int i = 0; i < this.items.size(); ++i) {
+            if (!this.items.get(i).isEmpty() && ItemStack.isSameItemSameTags(itemstack, this.items.get(i))) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public int findSlotMatchingUnusedItem(ItemStack itemStack) {
+        for(int i = 0; i < this.items.size(); ++i) {
+            ItemStack localItem = this.items.get(i);
+            if (!this.items.get(i).isEmpty() && ItemStack.isSameItemSameTags(itemStack, this.items.get(i)) && !this.items.get(i).isDamaged() && !localItem.isEnchanted() && !localItem.hasCustomHoverName()) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    @Override
+    public int getSuitableHotbarSlot() {
+        int i;
+        int j;
+        for(j = 0; j < 9; ++j) {
+            i = (this.selected + j) % 9;
+            if (this.items.get(i).isEmpty()) {
+                return i;
+            }
+        }
+
+        for(j = 0; j < 9; ++j) {
+            i = (this.selected + j) % 9;
+            if (!this.items.get(i).isEnchanted()) {
+                return i;
+            }
+        }
+
+        return this.selected;
+    }
+
+    @Override
+    public void swapPaint(double d0) {
+        if (d0 > 0.0D) {
+            d0 = 1.0D;
+        }
+
+        if (d0 < 0.0D) {
+            d0 = -1.0D;
+        }
+
+        this.selected = (int) (this.selected - d0);
+
+        while (this.selected < 0) {
+            this.selected += 9;
+        }
+
+        while(this.selected >= 9) {
+            this.selected -= 9;
+        }
+    }
+
+    @Override
+    public int clearOrCountMatchingItems(Predicate<ItemStack> predicate, int i, Container container) {
+        byte b0 = 0;
+        boolean flag = i == 0;
+        int j = b0 + ContainerHelper.clearOrCountMatchingItems(this, predicate, i - b0, flag);
+        j += ContainerHelper.clearOrCountMatchingItems(container, predicate, i - j, flag);
+        ItemStack itemstack = this.player.containerMenu.getCarried();
+        j += ContainerHelper.clearOrCountMatchingItems(itemstack, predicate, i - j, flag);
+        if (itemstack.isEmpty()) {
+            this.player.containerMenu.setCarried(ItemStack.EMPTY);
+        }
+
+        return j;
+    }
+
+    private int addResource(ItemStack itemstack) {
+        int i = this.getSlotWithRemainingSpace(itemstack);
+        if (i == -1) {
+            i = this.getFreeSlot();
+        }
+
+        return i == -1 ? itemstack.getCount() : this.addResource(i, itemstack);
+    }
+
+    private int addResource(int i, ItemStack itemstack) {
+        Item item = itemstack.getItem();
+        int j = itemstack.getCount();
+        ItemStack localItemStack = this.getRawItem(i);
+        if (localItemStack.isEmpty()) {
+            localItemStack = new ItemStack(item, 0);
+            if (itemstack.hasTag()) {
+                // hasTag ensures tag not null
+                //noinspection ConstantConditions
+                localItemStack.setTag(itemstack.getTag().copy());
+            }
+
+            this.setRawItem(i, localItemStack);
+        }
+
+        int k = Math.min(j, localItemStack.getMaxStackSize() - localItemStack.getCount());
+
+        if (k > this.getMaxStackSize() - localItemStack.getCount()) {
+            k = this.getMaxStackSize() - localItemStack.getCount();
+        }
+
+        if (k != 0) {
+            j -= k;
+            localItemStack.grow(k);
+            localItemStack.setPopTime(5);
+        }
+
+        return j;
+    }
+
+    @Override
+    public int getSlotWithRemainingSpace(ItemStack itemstack) {
+        if (this.hasRemainingSpaceForItem(this.getRawItem(this.selected), itemstack)) {
+            return this.selected;
+        } else if (this.hasRemainingSpaceForItem(this.getRawItem(40), itemstack)) {
+            return 40;
+        } else {
+            for(int i = 0; i < this.items.size(); ++i) {
+                if (this.hasRemainingSpaceForItem(this.items.get(i), itemstack)) {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+    }
+
+    @Override
+    public void tick() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                if (!compartment.get(i).isEmpty()) {
+                    compartment.get(i).inventoryTick(this.player.level(), this.player, i, this.selected == i);
+                }
+            }
+        }
+
+    }
+
+    @Override
+    public boolean add(ItemStack itemStack) {
+        return this.add(-1, itemStack);
+    }
+
+    @Override
+    public boolean add(int i, ItemStack itemStack) {
+        if (itemStack.isEmpty()) {
+            return false;
+        } else {
+            try {
+                if (itemStack.isDamaged()) {
+                    if (i == -1) {
+                        i = this.getFreeSlot();
+                    }
+
+                    if (i >= 0) {
+                        this.items.set(i, itemStack.copy());
+                        this.items.get(i).setPopTime(5);
+                        itemStack.setCount(0);
+                        return true;
+                    } else if (this.player.getAbilities().instabuild) {
+                        itemStack.setCount(0);
+                        return true;
+                    } else {
+                        return false;
+                    }
+                } else {
+                    int j;
+                    do {
+                        j = itemStack.getCount();
+                        if (i == -1) {
+                            itemStack.setCount(this.addResource(itemStack));
+                        } else {
+                            itemStack.setCount(this.addResource(i, itemStack));
+                        }
+                    } while(!itemStack.isEmpty() && itemStack.getCount() < j);
+
+                    if (itemStack.getCount() == j && this.player.getAbilities().instabuild) {
+                        itemStack.setCount(0);
+                        return true;
+                    } else {
+                        return itemStack.getCount() < j;
+                    }
+                }
+            } catch (Throwable var6) {
+                CrashReport crashReport = CrashReport.forThrowable(var6, "Adding item to inventory");
+                CrashReportCategory crashReportCategory = crashReport.addCategory("Item being added");
+                crashReportCategory.setDetail("Item ID", Item.getId(itemStack.getItem()));
+                crashReportCategory.setDetail("Item data", itemStack.getDamageValue());
+                crashReportCategory.setDetail("Item name", () -> itemStack.getHoverName().getString());
+                throw new ReportedException(crashReport);
+            }
+        }
+    }
+
+    @Override
+    public void placeItemBackInInventory(ItemStack itemStack) {
+        this.placeItemBackInInventory(itemStack, true);
+    }
+
+    @Override
+    public void placeItemBackInInventory(ItemStack itemStack, boolean flag) {
+        while(true) {
+            if (!itemStack.isEmpty()) {
+                int i = this.getSlotWithRemainingSpace(itemStack);
+                if (i == -1) {
+                    i = this.getFreeSlot();
+                }
+
+                if (i != -1) {
+                    int j = itemStack.getMaxStackSize() - this.getRawItem(i).getCount();
+                    if (this.add(i, itemStack.split(j)) && flag && this.player instanceof ServerPlayer) {
+                        ((ServerPlayer)this.player).connection.send(new ClientboundContainerSetSlotPacket(-2, 0, i, this.getRawItem(i)));
+                    }
+                    continue;
+                }
+
+                this.player.drop(itemStack, false);
+            }
+
+            return;
+        }
+    }
+
+    @Override
+    public ItemStack removeItem(int rawIndex, final int j) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null
+                || indexedCompartment.compartment().get(indexedCompartment.index()).isEmpty()) {
+            return ItemStack.EMPTY;
+        }
+
+        return ContainerHelper.removeItem(indexedCompartment.compartment(), indexedCompartment.index(), j);
+    }
+
+    @Override
+    public void removeItem(ItemStack itemStack) {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                if (compartment.get(i) == itemStack) {
+                    compartment.set(i, ItemStack.EMPTY);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public ItemStack removeItemNoUpdate(int rawIndex) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            return ItemStack.EMPTY;
+        }
+
+        ItemStack removed = indexedCompartment.compartment().set(indexedCompartment.index(), ItemStack.EMPTY);
+
+        if (removed.isEmpty()) {
+            return ItemStack.EMPTY;
+        }
+
+        return removed;
+    }
+
+    @Override
+    public void setItem(int rawIndex, final ItemStack itemStack) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            this.player.drop(itemStack, true);
+            return;
+        }
+
+        indexedCompartment.compartment().set(indexedCompartment.index(), itemStack);
+    }
+
+    @Override
+    public float getDestroySpeed(BlockState blockState) {
+        return this.items.get(this.selected).getDestroySpeed(blockState);
+    }
+
+    @Override
+    public ListTag save(ListTag listTag) {
+        for (int i = 0; i < this.items.size(); ++i) {
+            if (!this.items.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)i);
+                this.items.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        for (int i = 0; i < this.armor.size(); ++i) {
+            if (!this.armor.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)(i + 100));
+                this.armor.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        for (int i = 0; i < this.offhand.size(); ++i) {
+            if (!this.offhand.get(i).isEmpty()) {
+                CompoundTag compoundTag = new CompoundTag();
+                compoundTag.putByte("Slot", (byte)(i + 150));
+                this.offhand.get(i).save(compoundTag);
+                listTag.add(compoundTag);
+            }
+        }
+
+        return listTag;
+    }
+
+    @Override
+    public void load(ListTag listTag) {
+        this.items.clear();
+        this.armor.clear();
+        this.offhand.clear();
+
+        for(int i = 0; i < listTag.size(); ++i) {
+            CompoundTag compoundTag = listTag.getCompound(i);
+            int j = compoundTag.getByte("Slot") & 255;
+            ItemStack itemstack = ItemStack.of(compoundTag);
+            if (!itemstack.isEmpty()) {
+                if (j < this.items.size()) {
+                    this.items.set(j, itemstack);
+                } else if (j >= 100 && j < this.armor.size() + 100) {
+                    this.armor.set(j - 100, itemstack);
+                } else if (j >= 150 && j < this.offhand.size() + 150) {
+                    this.offhand.set(j - 150, itemstack);
+                }
+            }
+        }
+
+    }
+
+    @Override
+    public int getContainerSize() {
+        return 45;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return !contains(itemStack -> !itemStack.isEmpty());
+    }
+
+    @Override
+    public ItemStack getItem(int rawIndex) {
+        IndexedCompartment indexedCompartment = getIndexedContent(rawIndex);
+
+        if (indexedCompartment.compartment() == null) {
+            return ItemStack.EMPTY;
+        }
+
+        return indexedCompartment.compartment().get(indexedCompartment.index());
+    }
+
+    @Override
+    public Component getName() {
+        return this.player.getName();
+    }
+
+    @Override
+    public ItemStack getArmor(int index) {
+        return this.armor.get(index);
+    }
+
+    @Override
+    public void hurtArmor(DamageSource damagesource, float damage, int[] armorIndices) {
+        if (damage > 0.0F) {
+            damage /= 4.0F;
+            if (damage < 1.0F) {
+                damage = 1.0F;
+            }
+
+            for (int index : armorIndices) {
+                ItemStack itemstack = this.armor.get(index);
+                if ((!damagesource.is(DamageTypeTags.IS_FIRE) || !itemstack.getItem().isFireResistant()) && itemstack.getItem() instanceof ArmorItem) {
+                    itemstack.hurtAndBreak((int) damage, this.player, localPlayer -> localPlayer.broadcastBreakEvent(EquipmentSlot.byTypeAndIndex(EquipmentSlot.Type.ARMOR, index)));
+                }
+            }
+        }
+    }
+
+    @Override
+    public void dropAll() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            for (int i = 0; i < compartment.size(); ++i) {
+                ItemStack itemstack = compartment.get(i);
+                if (!itemstack.isEmpty()) {
+                    this.player.drop(itemstack, true, false);
+                    compartment.set(i, ItemStack.EMPTY);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void setChanged() {
+        super.setChanged();
+    }
+
+    @Override
+    public int getTimesChanged() {
+        return super.getTimesChanged();
+    }
+
+    @Override
+    public boolean stillValid(Player player) {
+        return true;
+    }
+
+    @Override
+    public boolean contains(ItemStack itemstack) {
+        return contains(itemStack -> itemStack.isEmpty() && itemStack.is(itemstack.getItem()));
+    }
+
+    @Override
+    public boolean contains(TagKey<Item> tagKey) {
+
+        return contains(itemStack -> !itemStack.isEmpty() && itemStack.is(tagKey));
+    }
+
+    @Override
+    public void replaceWith(Inventory inventory) {
+        Function<Integer, ItemStack> getter;
+
+        if (inventory instanceof SpecialPlayerInventory specialPlayerInventory) {
+            getter = specialPlayerInventory::getRawItem;
+        } else {
+            getter = inventory::getItem;
+        }
+
+        for(int i = 0; i < this.getContainerSize(); ++i) {
+            this.setRawItem(i, getter.apply(i));
+        }
+
+        this.selected = inventory.selected;
+    }
+
+    @Override
+    public void clearContent() {
+        for (NonNullList<ItemStack> compartment : this.compartments) {
+            compartment.clear();
+        }
+    }
+
+    @Override
+    public void fillStackedContents(StackedContents stackedContents) {
+        for (ItemStack itemstack : this.items) {
+            stackedContents.accountSimpleStack(itemstack);
+        }
+    }
+
+    @Override
+    public ItemStack removeFromSelected(boolean dropWholeStack) {
+        ItemStack itemstack = this.getSelected();
+        return itemstack.isEmpty() ? ItemStack.EMPTY : this.removeItem(this.selected, dropWholeStack ? itemstack.getCount() : 1);
+    }
+
+}
@@ -1,63 +0,0 @@
-<!--
-  ~ Copyright (C) 2011-2021 lishid. All rights reserved.
-  ~
-  ~ This program is free software: you can redistribute it and/or modify
-  ~ it under the terms of the GNU General Public License as published by
-  ~ the Free Software Foundation, version 3.
-  ~
-  ~ 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 General Public License for more details.
-  ~
-  ~ You should have received a copy of the GNU General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <artifactId>openinvparent</artifactId>
-    <groupId>com.lishid</groupId>
-    <version>4.1.9-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>openinvplugincore</artifactId>
-  <name>OpenInvPlugin</name>
-
-  <dependencies>
-    <dependency>
-      <artifactId>openinvapi</artifactId>
-      <groupId>com.lishid</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>annotations</artifactId>
-      <groupId>org.jetbrains</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>spigot-api</artifactId>
-      <groupId>org.spigotmc</groupId>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <resources>
-      <resource>
-        <directory>src/main/resources</directory>
-        <filtering>true</filtering>
-      </resource>
-    </resources>
-
-    <plugins>
-      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
-
-</project>
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2022 lishid. All rights reserved.
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -14,28 +14,29 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-package com.lishid.openinv.util;
+package com.lishid.openinv;

 import com.lishid.openinv.internal.IAnySilentContainer;
 import com.lishid.openinv.internal.IPlayerDataManager;
 import com.lishid.openinv.internal.ISpecialEnderChest;
 import com.lishid.openinv.internal.ISpecialInventory;
 import com.lishid.openinv.internal.ISpecialPlayerInventory;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
+import com.lishid.openinv.util.InventoryAccess;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.NotNull;

-public class InternalAccessor {
+import java.lang.reflect.Constructor;

-    private final Plugin plugin;
+class InternalAccessor {
+
+    private final @NotNull Plugin plugin;
    private final String version;
    private boolean supported = false;
    private IPlayerDataManager playerDataManager;
    private IAnySilentContainer anySilentContainer;

-    public InternalAccessor(final Plugin plugin) {
+    InternalAccessor(@NotNull Plugin plugin) {
        this.plugin = plugin;

        String packageName = plugin.getServer().getClass().getPackage().getName();
@@ -51,56 +52,33 @@ public class InternalAccessor {
    }

    public String getReleasesLink() {
-        switch (version) {
-            case "1_4_5":
-            case "1_4_6":
-            case "v1_4_R1":
-            case "v1_5_R2":
-            case "v1_5_R3":
-            case "v1_6_R1":
-            case "v1_6_R2":
-            case "v1_6_R3":
-            case "v1_7_R1":
-            case "v1_7_R2":
-            case "v1_7_R3":
-            case "v1_7_R4":
-            case "v1_8_R1":
-            case "v1_8_R2":
-            case "v1_9_R1":
-            case "v1_9_R2":
-            case "v1_10_R1":
-            case "v1_11_R1":
-            case "v1_12_R1":
-                return "https://github.com/lishid/OpenInv/releases/tag/4.0.0 (OpenInv-legacy)";
-            case "v1_13_R1":
-                return "https://github.com/lishid/OpenInv/releases/tag/4.0.0";
-            case "v1_13_R2":
-                return "https://github.com/lishid/OpenInv/releases/tag/4.0.7";
-            case "v1_14_R1":
-                return "https://github.com/lishid/OpenInv/releases/tag/4.1.1";
-            case "v1_16_R1":
-                return "https://github.com/lishid/OpenInv/releases/tag/4.1.4";
-            case "v1_8_R3":
-            case "v1_15_R1":
-            case "v1_16_R2":
-                return "https://github.com/lishid/OpenInv/releases/tag/4.1.5";
-            case "v1_16_R3":
-            default:
-                return "https://github.com/Jikoo/OpenInv/releases";
-        }
+
+        return switch (version) {
+            case "1_4_5", "1_4_6", "v1_4_R1", "v1_5_R2", "v1_5_R3", "v1_6_R1", "v1_6_R2", "v1_6_R3",
+                    "v1_7_R1", "v1_7_R2", "v1_7_R3", "v1_7_R4", "v1_8_R1", "v1_8_R2",
+                    "v1_9_R1", "v1_9_R2", "v1_10_R1", "v1_11_R1", "v1_12_R1"
+                    -> "https://github.com/lishid/OpenInv/releases/tag/4.0.0 (OpenInv-legacy)";
+            case "v1_13_R1" -> "https://github.com/lishid/OpenInv/releases/tag/4.0.0";
+            case "v1_13_R2" -> "https://github.com/lishid/OpenInv/releases/tag/4.0.7";
+            case "v1_14_R1" -> "https://github.com/lishid/OpenInv/releases/tag/4.1.1";
+            case "v1_16_R1" -> "https://github.com/lishid/OpenInv/releases/tag/4.1.4";
+            case "v1_8_R3", "v1_15_R1", "v1_16_R2" -> "https://github.com/lishid/OpenInv/releases/tag/4.1.5";
+            case "v1_16_R3" -> "https://github.com/Jikoo/OpenInv/releases/tag/4.1.8";
+            case "v1_17_R1", "v1_18_R1" -> "https://github.com/Jikoo/OpenInv/releases/tag/4.1.10";
+            case "v1_19_R1" -> "https://github.com/Jikoo/OpenInv/releases/tag/4.2.2";
+            case "v1_18_R2", "v1_19_R2" -> "https://github.com/Jikoo/OpenInv/releases/tag/4.3.0";
+            case "v1_20_R1" -> "https://github.com/Jikoo/OpenInv/releases/tag/4.4.1";
+            default -> "https://github.com/Jikoo/OpenInv/releases";
+        };
    }

-    private <T> T createObject(final Class<? extends T> assignableClass, final String className,
-            final Object... params) throws ClassCastException, ClassNotFoundException,
-            InstantiationException, IllegalAccessException, IllegalArgumentException,
-            InvocationTargetException, NoSuchMethodException, SecurityException {
+    private @NotNull <T> T createObject(
+            @NotNull Class<? extends T> assignableClass,
+            @NotNull String className,
+            @NotNull Object @NotNull ... params)
+            throws ClassCastException, ReflectiveOperationException {
        // Fetch internal class if it exists.
        Class<?> internalClass = Class.forName("com.lishid.openinv.internal." + this.version + "." + className);
-        if (!assignableClass.isAssignableFrom(internalClass)) {
-            String message = String.format("Found class %s but cannot cast to %s!", internalClass.getName(), assignableClass.getName());
-            this.plugin.getLogger().warning(message);
-            throw new IllegalStateException(message);
-        }

        // Quick return: no parameters, no need to fiddle about finding the correct constructor.
        if (params.length == 0) {
@@ -131,10 +109,10 @@ public class InternalAccessor {
        String message = builder.append(']').toString();
        this.plugin.getLogger().warning(message);

-        throw new IllegalArgumentException(message);
+        throw new NoSuchMethodException(message);
    }

-    private <T extends ISpecialInventory> T createSpecialInventory(
+    private @NotNull <T extends ISpecialInventory> T createSpecialInventory(
            @NotNull Class<? extends T> assignableClass,
            @NotNull String className,
            @NotNull Player player,
@@ -157,7 +135,7 @@ public class InternalAccessor {
     * @return the IAnySilentContainer
     * @throws IllegalStateException if server version is unsupported
     */
-    public IAnySilentContainer getAnySilentContainer() {
+    public @NotNull IAnySilentContainer getAnySilentContainer() {
        if (!this.supported) {
            throw new IllegalStateException(String.format("Unsupported server version %s!", this.version));
        }
@@ -170,7 +148,7 @@ public class InternalAccessor {
     * @return the IPlayerDataManager
     * @throws IllegalStateException if server version is unsupported
     */
-    public IPlayerDataManager getPlayerDataManager() {
+    public @NotNull IPlayerDataManager getPlayerDataManager() {
        if (!this.supported) {
            throw new IllegalStateException(String.format("Unsupported server version %s!", this.version));
        }
@@ -178,13 +156,12 @@ public class InternalAccessor {
    }

    /**
-     * Gets the server implementation version. If not initialized, returns the string "null"
-     * instead.
+     * Gets the server implementation version.
     *
-     * @return the version, or "null"
+     * @return the version
     */
-    public String getVersion() {
-        return this.version != null ? this.version : "null";
+    public @NotNull String getVersion() {
+        return this.version;
    }

    /**
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2023 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -14,9 +14,9 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-package com.lishid.openinv.listeners;
+package com.lishid.openinv;

-import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.ISpecialInventory;
 import com.lishid.openinv.internal.ISpecialPlayerInventory;
 import com.lishid.openinv.util.InventoryAccess;
 import com.lishid.openinv.util.Permissions;
@@ -35,6 +35,7 @@ import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.inventory.InventoryDragEvent;
 import org.bukkit.event.inventory.InventoryInteractEvent;
 import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.InventoryView;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
@@ -45,29 +46,34 @@ import org.jetbrains.annotations.Nullable;
 *
 * @author Jikoo
 */
-public class InventoryListener implements Listener {
-
-    private final OpenInv plugin;
-
-    public InventoryListener(final OpenInv plugin) {
-        this.plugin = plugin;
-    }
+record InventoryListener(OpenInv plugin) implements Listener {

    @EventHandler
-    public void onInventoryClose(@NotNull final InventoryCloseEvent event) {
-        if (!(event.getPlayer() instanceof Player)) {
+    private void onInventoryClose(@NotNull final InventoryCloseEvent event) {
+        if (!(event.getPlayer() instanceof Player player)) {
            return;
        }

-        Player player = (Player) event.getPlayer();
-
-        if (this.plugin.getPlayerSilentChestStatus(player)) {
+        InventoryHolder holder = event.getInventory().getHolder();
+        if (this.plugin.getSilentContainerStatus(player)
+                && holder != null
+                && this.plugin.getAnySilentContainer().isAnySilentContainer(holder)) {
            this.plugin.getAnySilentContainer().deactivateContainer(player);
        }
+
+        ISpecialInventory specialInventory = InventoryAccess.getEnderChest(event.getInventory());
+        if (specialInventory != null) {
+            this.plugin.handleCloseInventory(specialInventory);
+        } else {
+            specialInventory = InventoryAccess.getPlayerInventory(event.getInventory());
+            if (specialInventory != null) {
+                this.plugin.handleCloseInventory(specialInventory);
+            }
+        }
    }

    @EventHandler(priority = EventPriority.LOWEST)
-    public void onInventoryClick(@NotNull final InventoryClickEvent event) {
+    private void onInventoryClick(@NotNull final InventoryClickEvent event) {
        if (handleInventoryInteract(event)) {
            return;
        }
@@ -101,7 +107,7 @@ public class InventoryListener implements Listener {
    }

    @EventHandler(priority = EventPriority.LOWEST)
-    public void onInventoryDrag(@NotNull final InventoryDragEvent event) {
+    private void onInventoryDrag(@NotNull final InventoryDragEvent event) {
        if (handleInventoryInteract(event)) {
            return;
        }
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv;
+
+import com.lishid.openinv.internal.ISpecialInventory;
+import com.lishid.openinv.util.Permissions;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import org.jetbrains.annotations.NotNull;
+
+record OfflineHandler(
+        @NotNull BiFunction<Map<UUID, ? extends ISpecialInventory>, UUID, ISpecialInventory> fetch,
+        @NotNull Consumer<@NotNull ISpecialInventory> handle) {
+
+    static final OfflineHandler REMOVE_AND_CLOSE = new OfflineHandler(
+            Map::remove,
+            inventory -> OpenInv.ejectViewers(inventory, viewer -> true)
+    );
+
+    static final OfflineHandler REQUIRE_PERMISSIONS = new OfflineHandler(
+            Map::get,
+            inventory -> OpenInv.ejectViewers(inventory, viewer -> !Permissions.OPENOFFLINE.hasPermission(viewer))
+    );
+
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -16,34 +16,35 @@

 package com.lishid.openinv;

-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
 import com.lishid.openinv.commands.ContainerSettingCommand;
 import com.lishid.openinv.commands.OpenInvCommand;
 import com.lishid.openinv.commands.SearchContainerCommand;
 import com.lishid.openinv.commands.SearchEnchantCommand;
 import com.lishid.openinv.commands.SearchInvCommand;
+import com.lishid.openinv.event.OpenPlayerSaveEvent;
 import com.lishid.openinv.internal.IAnySilentContainer;
 import com.lishid.openinv.internal.ISpecialEnderChest;
 import com.lishid.openinv.internal.ISpecialInventory;
 import com.lishid.openinv.internal.ISpecialPlayerInventory;
-import com.lishid.openinv.listeners.InventoryListener;
-import com.lishid.openinv.listeners.PlayerListener;
-import com.lishid.openinv.listeners.PluginListener;
-import com.lishid.openinv.util.Cache;
 import com.lishid.openinv.util.ConfigUpdater;
-import com.lishid.openinv.util.InternalAccessor;
-import com.lishid.openinv.util.LanguageManager;
 import com.lishid.openinv.util.Permissions;
+import com.lishid.openinv.util.StringMetric;
+import com.lishid.openinv.util.lang.LanguageManager;
+import com.lishid.openinv.util.lang.Replacement;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.logging.Level;
+import java.util.stream.Stream;
 import net.md_5.bungee.api.ChatMessageType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.Bukkit;
@@ -56,10 +57,9 @@ import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryView;
-import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.java.JavaPlugin;
-import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.profile.PlayerProfile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -70,96 +70,123 @@ import org.jetbrains.annotations.Nullable;
 */
 public class OpenInv extends JavaPlugin implements IOpenInv {

-    private final Map<String, ISpecialPlayerInventory> inventories = new HashMap<>();
-    private final Map<String, ISpecialEnderChest> enderChests = new HashMap<>();
-    private final Multimap<String, Class<? extends Plugin>> pluginUsage = HashMultimap.create();
-
-    private final Cache<String, Player> playerCache = new Cache<>(300000L,
-            value -> {
-                String key = OpenInv.this.getPlayerID(value);
-
-                return OpenInv.this.inventories.containsKey(key)
-                        && OpenInv.this.inventories.get(key).isInUse()
-                        || OpenInv.this.enderChests.containsKey(key)
-                        && OpenInv.this.enderChests.get(key).isInUse()
-                        || OpenInv.this.pluginUsage.containsKey(key);
-            },
-            value -> {
-                String key = OpenInv.this.getPlayerID(value);
-
-                // Check if inventory is stored, and if it is, remove it and eject all viewers
-                if (OpenInv.this.inventories.containsKey(key)) {
-                    Inventory inv = OpenInv.this.inventories.remove(key).getBukkitInventory();
-                    List<HumanEntity> viewers = new ArrayList<>(inv.getViewers());
-                    for (HumanEntity entity : viewers.toArray(new HumanEntity[0])) {
-                        entity.closeInventory();
-                    }
-                }
-
-                // Check if ender chest is stored, and if it is, remove it and eject all viewers
-                if (OpenInv.this.enderChests.containsKey(key)) {
-                    Inventory inv = OpenInv.this.enderChests.remove(key).getBukkitInventory();
-                    List<HumanEntity> viewers = new ArrayList<>(inv.getViewers());
-                    for (HumanEntity entity : viewers.toArray(new HumanEntity[0])) {
-                        entity.closeInventory();
-                    }
-                }
-
-                if (!OpenInv.this.disableSaving() && !value.isOnline()) {
-                    value.saveData();
-                }
-            });
+    private final Cache<String, PlayerProfile> offlineLookUpCache = CacheBuilder.newBuilder().maximumSize(10).build();
+    private final Map<UUID, ISpecialPlayerInventory> inventories = new ConcurrentHashMap<>();
+    private final Map<UUID, ISpecialEnderChest> enderChests = new ConcurrentHashMap<>();

    private InternalAccessor accessor;
    private LanguageManager languageManager;
+    private boolean isSpigot = false;
+    private OfflineHandler offlineHandler;

-    /**
-     * Evicts all viewers lacking cross-world permissions from a Player's inventory.
-     *
-     * @param player the Player
-     */
-    public void changeWorld(final Player player) {
+    @Override
+    public void reloadConfig() {
+        super.reloadConfig();
+        this.offlineHandler = disableOfflineAccess() ? OfflineHandler.REMOVE_AND_CLOSE : OfflineHandler.REQUIRE_PERMISSIONS;
+    }

-        String key = this.getPlayerID(player);
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!isSpigot || !this.accessor.isSupported()) {
+            this.sendVersionError(sender::sendMessage);
+            return true;
+        }
+        return false;
+    }

-        // Check if the player is cached. If not, neither of their inventories is open.
-        if (!this.playerCache.containsKey(key)) {
+    @Override
+    public void onDisable() {
+        if (this.disableSaving()) {
            return;
        }

-        if (this.inventories.containsKey(key)) {
-            kickCrossWorldViewers(player, this.inventories.get(key));
-        }
-
-        if (this.enderChests.containsKey(key)) {
-            kickCrossWorldViewers(player, this.enderChests.get(key));
-        }
+        Stream.concat(inventories.values().stream(), enderChests.values().stream())
+                .map(inventory -> {
+                    // Cheat a bit - rather than stream twice, evict all viewers during remapping.
+                    ejectViewers(inventory, viewer -> true);
+                    if (inventory.getPlayer() instanceof Player player) {
+                        return player;
+                    }
+                    return null;
+                })
+                .filter(Objects::nonNull)
+                .distinct()
+                .forEach(player -> {
+                    if (!player.isOnline()) {
+                        player = accessor.getPlayerDataManager().inject(player);
+                    }
+                    player.saveData();
+                });
    }

-    private void kickCrossWorldViewers(Player player, ISpecialInventory inventory) {
-        List<HumanEntity> viewers = new ArrayList<>(inventory.getBukkitInventory().getViewers());
-        for (HumanEntity human : viewers) {
-            // If player has permission or is in the same world, allow continued access
-            // Just in case, also allow null worlds.
-            if (Permissions.CROSSWORLD.hasPermission(human) || Objects.equals(human.getWorld(), player.getWorld())) {
-                continue;
+    @Override
+    public void onEnable() {
+        // Save default configuration if not present.
+        this.saveDefaultConfig();
+
+        // Get plugin manager
+        PluginManager pm = this.getServer().getPluginManager();
+
+        this.accessor = new InternalAccessor(this);
+
+        this.languageManager = new LanguageManager(this, "en_us");
+        this.offlineHandler = disableOfflineAccess() ? OfflineHandler.REMOVE_AND_CLOSE : OfflineHandler.REQUIRE_PERMISSIONS;
+
+        try {
+            Class.forName("org.bukkit.entity.Player$Spigot");
+            isSpigot = true;
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+            isSpigot = false;
+        }
+
+        // Version check
+        if (isSpigot && this.accessor.isSupported()) {
+            // Update existing configuration. May require internal access.
+            new ConfigUpdater(this).checkForUpdates();
+
+            // Register listeners
+            pm.registerEvents(new PlayerListener(this), this);
+            pm.registerEvents(new InventoryListener(this), this);
+
+            // Register commands to their executors
+            this.setCommandExecutor(new OpenInvCommand(this), "openinv", "openender");
+            this.setCommandExecutor(new SearchContainerCommand(this), "searchcontainer");
+            this.setCommandExecutor(new SearchInvCommand(this), "searchinv", "searchender");
+            this.setCommandExecutor(new SearchEnchantCommand(this), "searchenchant");
+            this.setCommandExecutor(new ContainerSettingCommand(this), "silentcontainer", "anycontainer");
+
+        } else {
+            this.sendVersionError(this.getLogger()::warning);
+        }
+
+    }
+
+    private void setCommandExecutor(@NotNull CommandExecutor executor, String @NotNull ... commands) {
+        for (String commandName : commands) {
+            PluginCommand command = this.getCommand(commandName);
+            if (command != null) {
+                command.setExecutor(executor);
            }
-            human.closeInventory();
        }
    }

-    /**
-     * Convert a raw slot number into a player inventory slot number.
-     *
-     * <p>Note that this method is specifically for converting an ISpecialPlayerInventory slot number into a regular
-     * player inventory slot number.
-     *
-     * @param view the open inventory view
-     * @param rawSlot the raw slot in the view
-     * @return the converted slot number
-     */
-    public int convertToPlayerSlot(InventoryView view, int rawSlot) {
-        return this.accessor.getPlayerDataManager().convertToPlayerSlot(view, rawSlot);
+    private void sendVersionError(@NotNull Consumer<String> messageMethod) {
+        if (!this.accessor.isSupported()) {
+            messageMethod.accept("Your server version (" + this.accessor.getVersion() + ") is not supported.");
+            messageMethod.accept("Please download the correct version of OpenInv here: " + this.accessor.getReleasesLink());
+        }
+        if (!isSpigot) {
+            messageMethod.accept("OpenInv requires that you use Spigot or a Spigot fork. Per the 1.14 update thread");
+            messageMethod.accept("(https://www.spigotmc.org/threads/369724/ \"A Note on CraftBukkit\"), if you are");
+            messageMethod.accept("encountering an inconsistency with vanilla that prevents you from using Spigot,");
+            messageMethod.accept("that is considered a Spigot bug and should be reported as such.");
+        }
+    }
+
+    @Override
+    public boolean isSupportedVersion() {
+        return this.accessor != null && this.accessor.isSupported();
    }

    @Override
@@ -167,28 +194,43 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
        return this.getConfig().getBoolean("settings.disable-saving", false);
    }

-    @NotNull
    @Override
-    public IAnySilentContainer getAnySilentContainer() {
+    public boolean disableOfflineAccess() {
+        return this.getConfig().getBoolean("settings.disable-offline-access", false);
+    }
+
+    @Override
+    public boolean noArgsOpensSelf() {
+        return this.getConfig().getBoolean("settings.command.open.no-args-opens-self", false);
+    }
+
+    @Override
+    public @NotNull IAnySilentContainer getAnySilentContainer() {
        return this.accessor.getAnySilentContainer();
    }

    @Override
-    public boolean getPlayerAnyChestStatus(@NotNull final OfflinePlayer player) {
+    public boolean getAnyContainerStatus(@NotNull final OfflinePlayer offline) {
        boolean defaultState = false;

-        if (player.isOnline()) {
-            Player onlinePlayer = player.getPlayer();
+        if (offline.isOnline()) {
+            Player onlinePlayer = offline.getPlayer();
            if (onlinePlayer != null) {
                defaultState = Permissions.ANY_DEFAULT.hasPermission(onlinePlayer);
            }
        }

-        return this.getConfig().getBoolean("toggles.any-chest." + this.getPlayerID(player), defaultState);
+        return this.getConfig().getBoolean("toggles.any-chest." + offline.getUniqueId(), defaultState);
    }

    @Override
-    public boolean getPlayerSilentChestStatus(@NotNull final OfflinePlayer offline) {
+    public void setAnyContainerStatus(@NotNull final OfflinePlayer offline, final boolean status) {
+        this.getConfig().set("toggles.any-chest." + offline.getUniqueId(), status);
+        this.saveConfig();
+    }
+
+    @Override
+    public boolean getSilentContainerStatus(@NotNull final OfflinePlayer offline) {
        boolean defaultState = false;

        if (offline.isOnline()) {
@@ -198,57 +240,71 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
            }
        }

-        return this.getConfig().getBoolean("toggles.silent-chest." + this.getPlayerID(offline), defaultState);
+        return this.getConfig().getBoolean("toggles.silent-chest." + offline.getUniqueId(), defaultState);
    }

-    @NotNull
    @Override
-    public ISpecialEnderChest getSpecialEnderChest(@NotNull final Player player, final boolean online)
+    public void setSilentContainerStatus(@NotNull final OfflinePlayer offline, final boolean status) {
+        this.getConfig().set("toggles.silent-chest." + offline.getUniqueId(), status);
+        this.saveConfig();
+    }
+
+    @Override
+    public @NotNull ISpecialEnderChest getSpecialEnderChest(@NotNull final Player player, final boolean online)
            throws InstantiationException {
-        String id = this.getPlayerID(player);
-        if (this.enderChests.containsKey(id)) {
-            return this.enderChests.get(id);
+        UUID key = player.getUniqueId();
+
+        if (this.enderChests.containsKey(key)) {
+            return this.enderChests.get(key);
        }
+
        ISpecialEnderChest inv = this.accessor.newSpecialEnderChest(player, online);
-        this.enderChests.put(id, inv);
-        this.playerCache.put(id, player);
+        this.enderChests.put(key, inv);
        return inv;
    }

-    @NotNull
    @Override
-    public ISpecialPlayerInventory getSpecialInventory(@NotNull final Player player, final boolean online)
+    public @NotNull ISpecialPlayerInventory getSpecialInventory(@NotNull final Player player, final boolean online)
            throws InstantiationException {
-        String id = this.getPlayerID(player);
-        if (this.inventories.containsKey(id)) {
-            return this.inventories.get(id);
+        UUID key = player.getUniqueId();
+
+        if (this.inventories.containsKey(key)) {
+            return this.inventories.get(key);
        }
+
        ISpecialPlayerInventory inv = this.accessor.newSpecialPlayerInventory(player, online);
-        this.inventories.put(id, inv);
-        this.playerCache.put(id, player);
+        this.inventories.put(key, inv);
        return inv;
    }

    @Override
-    public boolean isSupportedVersion() {
-        return this.accessor != null && this.accessor.isSupported();
+    public @Nullable InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {
+        return this.accessor.getPlayerDataManager().openInventory(player, inventory);
+    }
+
+    @Override
+    public boolean isPlayerLoaded(@NotNull UUID playerUuid) {
+        return this.inventories.containsKey(playerUuid) || this.enderChests.containsKey(playerUuid);
    }

    @Override
    public @Nullable Player loadPlayer(@NotNull final OfflinePlayer offline) {
+        UUID key = offline.getUniqueId();

-        String key = this.getPlayerID(offline);
-        if (this.playerCache.containsKey(key)) {
-            return this.playerCache.get(key);
+        if (this.inventories.containsKey(key)) {
+            return (Player) this.inventories.get(key).getPlayer();
+        }
+
+        if (this.enderChests.containsKey(key)) {
+            return (Player) this.enderChests.get(key).getPlayer();
        }

        Player player = offline.getPlayer();
        if (player != null) {
-            this.playerCache.put(key, player);
            return player;
        }

-        if (!this.isSupportedVersion()) {
+        if (disableOfflineAccess() || !this.isSupportedVersion()) {
            return null;
        }

@@ -266,28 +322,171 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
            return null;
        }

-        if (player != null) {
-            this.playerCache.put(key, player);
-        }
-
        return player;
    }

    @Override
-    public @Nullable InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {
-        return this.accessor.getPlayerDataManager().openInventory(player, inventory);
+    public @Nullable OfflinePlayer matchPlayer(@NotNull String name) {
+
+        // Warn if called on the main thread - if we resort to searching offline players, this may take several seconds.
+        if (Bukkit.getServer().isPrimaryThread()) {
+            this.getLogger().warning("Call to OpenInv#matchPlayer made on the main thread!");
+            this.getLogger().warning("This can cause the server to hang, potentially severely.");
+            this.getLogger().log(Level.WARNING, "Current stack trace", new Throwable("Current stack trace"));
+        }
+
+        OfflinePlayer player;
+
+        try {
+            UUID uuid = UUID.fromString(name);
+            player = Bukkit.getOfflinePlayer(uuid);
+            // Ensure player is an existing player.
+            if (player.hasPlayedBefore() || player.isOnline()) {
+                return player;
+            }
+            // Return null otherwise.
+            return null;
+        } catch (IllegalArgumentException ignored) {
+            // Not a UUID
+        }
+
+        // Exact online match first.
+        player = Bukkit.getServer().getPlayerExact(name);
+
+        if (player != null) {
+            return player;
+        }
+
+        // Cached offline match.
+        PlayerProfile cachedResult = offlineLookUpCache.getIfPresent(name);
+        if (cachedResult != null && cachedResult.getUniqueId() != null) {
+            player = Bukkit.getOfflinePlayer(cachedResult.getUniqueId());
+            // Ensure player is an existing player.
+            if (player.hasPlayedBefore() || player.isOnline()) {
+                return player;
+            }
+            // Return null otherwise.
+            return null;
+        }
+
+        // Exact offline match second - ensure offline access works when matchable users are online.
+        player = Bukkit.getServer().getOfflinePlayer(name);
+
+        if (player.hasPlayedBefore()) {
+            offlineLookUpCache.put(name, player.getPlayerProfile());
+            return player;
+        }
+
+        // Inexact online match.
+        player = Bukkit.getServer().getPlayer(name);
+
+        if (player != null) {
+            return player;
+        }
+
+        // Finally, inexact offline match.
+        float bestMatch = 0;
+        for (OfflinePlayer offline : Bukkit.getServer().getOfflinePlayers()) {
+            if (offline.getName() == null) {
+                // Loaded by UUID only, name has never been looked up.
+                continue;
+            }
+
+            float currentMatch = StringMetric.compareJaroWinkler(name, offline.getName());
+
+            if (currentMatch == 1.0F) {
+                return offline;
+            }
+
+            if (currentMatch > bestMatch) {
+                bestMatch = currentMatch;
+                player = offline;
+            }
+        }
+
+        if (player != null) {
+            // If a match was found, store it.
+            offlineLookUpCache.put(name, player.getPlayerProfile());
+            return player;
+        }
+
+        // No players have ever joined the server.
+        return null;
+    }
+
+    @Override
+    public void unload(@NotNull final OfflinePlayer offline) {
+        setPlayerOffline(offline, OfflineHandler.REMOVE_AND_CLOSE);
+    }
+
+    /**
+     * Evict all viewers lacking cross-world permissions when a {@link Player} changes worlds.
+     *
+     * @param player the Player
+     */
+    void changeWorld(@NotNull Player player) {
+        UUID key = player.getUniqueId();
+
+        if (this.inventories.containsKey(key)) {
+            kickCrossWorldViewers(player, this.inventories.get(key));
+        }
+
+        if (this.enderChests.containsKey(key)) {
+            kickCrossWorldViewers(player, this.enderChests.get(key));
+        }
+    }
+
+    private void kickCrossWorldViewers(@NotNull Player player, @NotNull ISpecialInventory inventory) {
+        ejectViewers(
+                inventory,
+                viewer ->
+                        !Permissions.CROSSWORLD.hasPermission(viewer)
+                                && !Objects.equals(viewer.getWorld(), player.getWorld()));
+    }
+
+    /**
+     * Convert a raw slot number into a player inventory slot number.
+     *
+     * <p>Note that this method is specifically for converting an ISpecialPlayerInventory slot number into a regular
+     * player inventory slot number.
+     *
+     * @param view    the open inventory view
+     * @param rawSlot the raw slot in the view
+     * @return the converted slot number
+     */
+    int convertToPlayerSlot(InventoryView view, int rawSlot) {
+        return this.accessor.getPlayerDataManager().convertToPlayerSlot(view, rawSlot);
+    }
+
+    public @Nullable String getLocalizedMessage(@NotNull CommandSender sender, @NotNull String key) {
+        return this.languageManager.getValue(key, getLocale(sender));
+    }
+
+    public @Nullable String getLocalizedMessage(
+            @NotNull CommandSender sender,
+            @NotNull String key,
+            Replacement @NotNull ... replacements) {
+        return this.languageManager.getValue(key, getLocale(sender), replacements);
+    }
+
+    private @NotNull String getLocale(@NotNull CommandSender sender) {
+        if (sender instanceof Player) {
+            return ((Player) sender).getLocale();
+        } else {
+            return this.getConfig().getString("settings.locale", "en_us");
+        }
    }

    public void sendMessage(@NotNull CommandSender sender, @NotNull String key) {
-        String message = this.languageManager.getValue(key, getLocale(sender));
+        String message = getLocalizedMessage(sender, key);

        if (message != null && !message.isEmpty()) {
            sender.sendMessage(message);
        }
    }

-    public void sendMessage(@NotNull CommandSender sender, @NotNull String key, String... replacements) {
-        String message = this.languageManager.getValue(key, getLocale(sender), replacements);
+    public void sendMessage(@NotNull CommandSender sender, @NotNull String key, Replacement @NotNull... replacements) {
+        String message = getLocalizedMessage(sender, key, replacements);

        if (message != null && !message.isEmpty()) {
            sender.sendMessage(message);
@@ -295,7 +494,7 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
    }

    public void sendSystemMessage(@NotNull Player player, @NotNull String key) {
-        String message = this.languageManager.getValue(key, getLocale(player));
+        String message = getLocalizedMessage(player, key);

        if (message == null) {
            return;
@@ -314,160 +513,84 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
        player.spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(message));
    }

-    public @Nullable String getLocalizedMessage(@NotNull CommandSender sender, @NotNull String key) {
-        return this.languageManager.getValue(key, getLocale(sender));
-    }
-
-    public @Nullable String getLocalizedMessage(@NotNull CommandSender sender, @NotNull String key, String... replacements) {
-        return this.languageManager.getValue(key, getLocale(sender), replacements);
-    }
-
-    private @NotNull String getLocale(@NotNull CommandSender sender) {
-        if (sender instanceof Player) {
-            return ((Player) sender).getLocale();
-        } else {
-            return this.getConfig().getString("settings.locale", "en_us");
-        }
-    }
-
-    @Override
-    public void onDisable() {
-
-        if (this.disableSaving()) {
-            return;
-        }
-
-        if (this.isSupportedVersion()) {
-            this.playerCache.invalidateAll();
-        }
-    }
-
-    @Override
-    public void onEnable() {
-
-        // Save default configuration if not present.
-        this.saveDefaultConfig();
-
-        // Get plugin manager
-        PluginManager pm = this.getServer().getPluginManager();
-
-        this.accessor = new InternalAccessor(this);
-
-        this.languageManager = new LanguageManager(this, "en_us");
-
-        // Version check
-        if (this.accessor.isSupported()) {
-            // Update existing configuration. May require internal access.
-            new ConfigUpdater(this).checkForUpdates();
-
-            // Register listeners
-            pm.registerEvents(new PlayerListener(this), this);
-            pm.registerEvents(new PluginListener(this), this);
-            pm.registerEvents(new InventoryListener(this), this);
-
-            // Register commands to their executors
-            this.setCommandExecutor(new OpenInvCommand(this), "openinv", "openender");
-            this.setCommandExecutor(new SearchContainerCommand(this), "searchcontainer");
-            this.setCommandExecutor(new SearchInvCommand(this), "searchinv", "searchender");
-            this.setCommandExecutor(new SearchEnchantCommand(this), "searchenchant");
-            this.setCommandExecutor(new ContainerSettingCommand(this), "silentcontainer", "anycontainer");
-
-        } else {
-            this.sendVersionError(this.getLogger()::warning);
-        }
-
-    }
-
-    private void sendVersionError(Consumer<String> messageMethod) {
-        messageMethod.accept("Your server version (" + this.accessor.getVersion() + ") is not supported.");
-        messageMethod.accept("Please obtain an appropriate version here: " + accessor.getReleasesLink());
-    }
-
-    private void setCommandExecutor(CommandExecutor executor, String... commands) {
-        for (String commandName : commands) {
-            PluginCommand command = this.getCommand(commandName);
-            if (command != null) {
-                command.setExecutor(executor);
-            }
-        }
-    }
-
-    @Override
-    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
-        if (!this.accessor.isSupported()) {
-            this.sendVersionError(sender::sendMessage);
-            return true;
-        }
-        return false;
-    }
-
-    public void releaseAllPlayers(final Plugin plugin) {
-        Iterator<Map.Entry<String, Class<? extends Plugin>>> iterator = this.pluginUsage.entries().iterator();
-
-        if (!iterator.hasNext()) {
-            return;
-        }
-
-        for (Map.Entry<String, Class<? extends Plugin>> entry = iterator.next(); iterator.hasNext(); entry = iterator.next()) {
-            if (entry.getValue().equals(plugin.getClass())) {
-                iterator.remove();
-            }
-        }
-    }
-
-    @Override
-    public void releasePlayer(@NotNull final Player player, @NotNull final Plugin plugin) {
-        String key = this.getPlayerID(player);
-
-        if (!this.pluginUsage.containsEntry(key, plugin.getClass())) {
-            return;
-        }
-
-        this.pluginUsage.remove(key, plugin.getClass());
-    }
-
-    @Override
-    public void retainPlayer(@NotNull final Player player, @NotNull final Plugin plugin) {
-        String key = this.getPlayerID(player);
-
-        if (this.pluginUsage.containsEntry(key, plugin.getClass())) {
-            return;
-        }
-
-        this.pluginUsage.put(key, plugin.getClass());
-    }
-
-    @Override
-    public void setPlayerAnyChestStatus(@NotNull final OfflinePlayer offline, final boolean status) {
-        this.getConfig().set("toggles.any-chest." + this.getPlayerID(offline), status);
-        this.saveConfig();
-    }
-
    /**
     * Method for handling a Player going offline.
     *
     * @param player the Player
-     * @throws IllegalStateException if the server version is unsupported
     */
-    public void setPlayerOffline(final Player player) {
+    void setPlayerOffline(@NotNull Player player) {
+        setPlayerOffline(player, offlineHandler);
+    }

-        String key = this.getPlayerID(player);
+    private void setPlayerOffline(@NotNull OfflinePlayer player, @NotNull OfflineHandler handler) {
+        UUID key = player.getUniqueId();

-        // Check if the player is cached. If not, neither of their inventories is open.
-        if (!this.playerCache.containsKey(key)) {
+        setPlayerOffline(inventories, key, handler);
+        setPlayerOffline(enderChests, key, handler);
+    }
+
+    private void setPlayerOffline(
+            @NotNull Map<UUID, ? extends ISpecialInventory> map,
+            @NotNull UUID key,
+            @NotNull OfflineHandler handler) {
+        ISpecialInventory inventory = handler.fetch().apply(map, key);
+        if (inventory == null) {
+            return;
+        }
+        inventory.setPlayerOffline();
+        if (!inventory.isInUse()) {
+            map.remove(key);
+        } else {
+            handler.handle().accept(inventory);
+        }
+    }
+
+    void handleCloseInventory(@NotNull ISpecialInventory inventory) {
+        Map<UUID, ? extends ISpecialInventory> map = inventory instanceof ISpecialPlayerInventory ? inventories : enderChests;
+        UUID key = inventory.getPlayer().getUniqueId();
+        @Nullable ISpecialInventory loaded = map.get(key);
+
+        if (loaded == null) {
+            // Loaded inventory has already been removed. Removal will handle saving if necessary.
            return;
        }

-        // Replace stored player with our own version
-        this.playerCache.put(key, this.accessor.getPlayerDataManager().inject(player));
-
-        if (this.inventories.containsKey(key)) {
-            this.inventories.get(key).setPlayerOffline();
+        // This should only be possible if a plugin is doing funky things with our inventories.
+        if (loaded != inventory) {
+            Inventory bukkitInventory = inventory.getBukkitInventory();
+            // Just in case, respect contents of the inventory that was just used.
+            loaded.getBukkitInventory().setContents(bukkitInventory.getContents());
+            // We need to close this inventory to reduce risk of duplication bugs if the user is offline.
+            // We don't want to risk recursively closing the same inventory repeatedly, so we schedule dumping viewers.
+            // Worst case we schedule a couple redundant tasks if several people had the inventory open.
+            if (inventory.isInUse()) {
+                getServer().getScheduler().runTask(this, () -> ejectViewers(inventory, viewer -> true));
+            }
        }

-        if (this.enderChests.containsKey(key)) {
-            this.enderChests.get(key).setPlayerOffline();
-        }
+        // Schedule task to check in use status later this tick. Closing user is still in viewer list.
+        getServer().getScheduler().runTask(this, () -> {
+            if (loaded.isInUse()) {
+                return;
+            }
+
+            // Re-fetch from map - prevents duplicate saves on multi-close.
+            ISpecialInventory current = map.remove(key);
+
+            if (disableSaving()
+                || current == null
+                || !(current.getPlayer() instanceof Player player)
+                || player.isOnline()) {
+                return;
+            }
+
+            OpenPlayerSaveEvent event = new OpenPlayerSaveEvent(player, current);
+            getServer().getPluginManager().callEvent(event);
+
+            if (!event.isCancelled()) {
+                this.accessor.getPlayerDataManager().inject(player).saveData();
+            }
+        });
    }

    /**
@@ -476,78 +599,88 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
     * @param player the Player
     * @throws IllegalStateException if the server version is unsupported
     */
-    public void setPlayerOnline(final Player player) {
+    void setPlayerOnline(@NotNull Player player) {
+        setPlayerOnline(inventories, player, player::updateInventory);
+        setPlayerOnline(enderChests, player, null);

-        String key = this.getPlayerID(player);
-
-        // Check if the player is cached. If not, neither of their inventories is open.
-        if (!this.playerCache.containsKey(key)) {
+        if (player.hasPlayedBefore()) {
            return;
        }

-        this.playerCache.put(key, player);
+        // New player may have a name that already points to someone else in lookup cache.
+        String name = player.getName();
+        this.offlineLookUpCache.invalidate(name);

-        if (this.inventories.containsKey(key)) {
-            this.inventories.get(key).setPlayerOnline(player);
-            new BukkitRunnable() {
-                @Override
-                public void run() {
-                    if (player.isOnline()) {
-                        player.updateInventory();
-                    }
+        // If no offline matches are mapped, don't hit scheduler.
+        if (this.offlineLookUpCache.size() == 0) {
+            return;
+        }
+
+        // New player may also be a more exact match than one already in the cache.
+        // I.e. new player "lava1" is a better match for "lava" than "lava123"
+        // Player joins are already quite intensive, so this is run on a delay.
+        this.getServer().getScheduler().runTaskLaterAsynchronously(this, () -> {
+            Iterator<Map.Entry<String, PlayerProfile>> iterator = this.offlineLookUpCache.asMap().entrySet().iterator();
+            while (iterator.hasNext()) {
+                Map.Entry<String, PlayerProfile> entry = iterator.next();
+                String oldMatch = entry.getValue().getName();
+
+                // Shouldn't be possible - all profiles should be complete.
+                if (oldMatch == null) {
+                    iterator.remove();
+                    continue;
                }
-            }.runTask(this);
+
+                String lookup = entry.getKey();
+                float oldMatchScore = StringMetric.compareJaroWinkler(lookup, oldMatch);
+                float newMatchScore = StringMetric.compareJaroWinkler(lookup, name);
+
+                // If new match exceeds old match, delete old match.
+                if (newMatchScore > oldMatchScore) {
+                    iterator.remove();
+                }
+            }
+        }, 101L); // Odd delay for pseudo load balancing; Player tasks are usually scheduled with full seconds.
+    }
+
+    private void setPlayerOnline(
+            @NotNull Map<UUID, ? extends ISpecialInventory> map,
+            @NotNull Player player,
+            @Nullable Runnable task) {
+        ISpecialInventory inventory = map.get(player.getUniqueId());
+
+        if (inventory == null) {
+            // Inventory not open.
+            return;
        }

-        if (this.enderChests.containsKey(key)) {
-            this.enderChests.get(key).setPlayerOnline(player);
+        inventory.setPlayerOnline(player);
+
+        // Eject viewers lacking permission.
+        ejectViewers(
+                inventory,
+                viewer ->
+                        !Permissions.OPENONLINE.hasPermission(viewer)
+                                || !Permissions.CROSSWORLD.hasPermission(viewer)
+                                && !Objects.equals(viewer.getWorld(), inventory.getPlayer().getWorld()));
+
+        if (task != null) {
+            getServer().getScheduler().runTask(this, task);
        }
    }

-    @Override
-    public void setPlayerSilentChestStatus(@NotNull final OfflinePlayer offline, final boolean status) {
-        this.getConfig().set("toggles.silent-chest." + this.getPlayerID(offline), status);
-        this.saveConfig();
-    }
-
-    /**
-     * Displays all applicable help for OpenInv commands.
-     *
-     * @param player the Player to help
-     */
-    public void showHelp(final Player player) {
-        // Get registered commands
-        for (String commandName : this.getDescription().getCommands().keySet()) {
-            PluginCommand command = this.getCommand(commandName);
-
-            // Ensure command is successfully registered and player can use it
-            if (command == null  || !command.testPermissionSilent(player)) {
+    static void ejectViewers(@NotNull ISpecialInventory inventory, @NotNull Predicate<@NotNull HumanEntity> predicate) {
+        Inventory bukkitInventory = inventory.getBukkitInventory();
+        for (HumanEntity viewer : new ArrayList<>(bukkitInventory.getViewers())) {
+            if (viewer.getUniqueId().equals(inventory.getPlayer().getUniqueId())
+                    && !viewer.getOpenInventory().getTopInventory().equals(bukkitInventory)) {
+                // Skip owner with other inventory open. They aren't actually a viewer.
                continue;
            }
-
-            // Send usage
-            player.sendMessage(command.getUsage().replace("<command>", commandName));
-
-            List<String> aliases = command.getAliases();
-            if (aliases.isEmpty()) {
-                continue;
+            if (predicate.test(viewer)) {
+                viewer.closeInventory();
            }
-
-            // Assemble alias list
-            StringBuilder aliasBuilder = new StringBuilder("   (aliases: ");
-            for (String alias : aliases) {
-                aliasBuilder.append(alias).append(", ");
-            }
-            aliasBuilder.delete(aliasBuilder.length() - 2, aliasBuilder.length()).append(')');
-
-            // Send all aliases
-            player.sendMessage(aliasBuilder.toString());
        }
    }

-    @Override
-    public void unload(@NotNull final OfflinePlayer offline) {
-        this.playerCache.invalidate(this.getPlayerID(offline));
-    }
-
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -14,9 +14,8 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-package com.lishid.openinv.listeners;
+package com.lishid.openinv;

-import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.util.Permissions;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Event.Result;
@@ -28,32 +27,27 @@ import org.bukkit.event.player.PlayerChangedWorldEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
+import org.jetbrains.annotations.NotNull;

-public class PlayerListener implements Listener {
-
-    private final OpenInv plugin;
-
-    public PlayerListener(OpenInv plugin) {
-        this.plugin = plugin;
-    }
+record PlayerListener(OpenInv plugin) implements Listener {

    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerJoin(final PlayerJoinEvent event) {
+    private void onPlayerJoin(@NotNull PlayerJoinEvent event) {
        plugin.setPlayerOnline(event.getPlayer());
    }

    @EventHandler(priority = EventPriority.MONITOR)
-    public void onPlayerQuit(PlayerQuitEvent event) {
+    private void onPlayerQuit(@NotNull PlayerQuitEvent event) {
        plugin.setPlayerOffline(event.getPlayer());
    }

    @EventHandler
-    public void onWorldChange(PlayerChangedWorldEvent event) {
+    private void onWorldChange(@NotNull PlayerChangedWorldEvent event) {
        plugin.changeWorld(event.getPlayer());
    }

    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerInteract(PlayerInteractEvent event) {
+    private void onPlayerInteract(@NotNull PlayerInteractEvent event) {

        // Do not cancel 3rd party plugins' custom events
        if (!PlayerInteractEvent.class.equals(event.getClass())) {
@@ -67,23 +61,23 @@ public class PlayerListener implements Listener {
        }

        Player player = event.getPlayer();
-        boolean any = Permissions.ANYCHEST.hasPermission(player) && plugin.getPlayerAnyChestStatus(player);
-        boolean needsAny = plugin.getAnySilentContainer().isAnyContainerNeeded(player, event.getClickedBlock());
+        boolean any = Permissions.ANYCHEST.hasPermission(player) && plugin.getAnyContainerStatus(player);
+        boolean needsAny = plugin.getAnySilentContainer().isAnyContainerNeeded(event.getClickedBlock());

        if (!any && needsAny) {
            return;
        }

-        boolean silent = Permissions.SILENT.hasPermission(player) && plugin.getPlayerSilentChestStatus(player);
+        boolean silent = Permissions.SILENT.hasPermission(player) && plugin.getSilentContainerStatus(player);

        // If anycontainer or silentcontainer is active
        if (any || silent) {
            if (plugin.getAnySilentContainer().activateContainer(player, silent, event.getClickedBlock())) {
-                if (silent && plugin.notifySilentChest() && needsAny && plugin.notifyAnyChest()) {
+                if (silent && needsAny) {
                    plugin.sendSystemMessage(player, "messages.info.containerBlockedSilent");
-                } else if (needsAny && plugin.notifyAnyChest()) {
+                } else if (needsAny) {
                    plugin.sendSystemMessage(player, "messages.info.containerBlocked");
-                } else if (silent && plugin.notifySilentChest()) {
+                } else if (silent) {
                    plugin.sendSystemMessage(player, "messages.info.containerSilent");
                }
            }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -18,6 +18,7 @@ package com.lishid.openinv.commands;

 import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.util.TabCompleter;
+import com.lishid.openinv.util.lang.Replacement;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.BiConsumer;
@@ -39,15 +40,14 @@ public class ContainerSettingCommand implements TabExecutor {

    @Override
    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
-        if (!(sender instanceof Player)) {
+        if (!(sender instanceof Player player)) {
            plugin.sendMessage(sender, "messages.error.consoleUnsupported");
            return true;
        }

-        Player player = (Player) sender;
        boolean any = command.getName().startsWith("any");
-        Predicate<Player> getSetting = any ? plugin::getPlayerAnyChestStatus : plugin::getPlayerSilentChestStatus;
-        BiConsumer<OfflinePlayer, Boolean> setSetting = any ? plugin::setPlayerAnyChestStatus : plugin::setPlayerSilentChestStatus;
+        Predicate<Player> getSetting = any ? plugin::getAnyContainerStatus : plugin::getSilentContainerStatus;
+        BiConsumer<OfflinePlayer, Boolean> setSetting = any ? plugin::setAnyContainerStatus : plugin::setSilentContainerStatus;

        if (args.length > 0) {
            args[0] = args[0].toLowerCase();
@@ -70,7 +70,11 @@ public class ContainerSettingCommand implements TabExecutor {
            onOff = String.valueOf(getSetting.test(player));
        }

-        plugin.sendMessage(sender, "messages.info.settingState","%setting%", any ? "AnyContainer" : "SilentContainer", "%state%", onOff);
+        plugin.sendMessage(
+                sender,
+                "messages.info.settingState",
+                new Replacement("%setting%", any ? "AnyContainer" : "SilentContainer"),
+                new Replacement("%state%", onOff));

        return true;
    }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,12 +20,15 @@ import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.internal.ISpecialInventory;
 import com.lishid.openinv.util.Permissions;
 import com.lishid.openinv.util.TabCompleter;
+import com.lishid.openinv.util.lang.Replacement;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
+import java.util.StringJoiner;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.PluginCommand;
 import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitRunnable;
@@ -43,32 +46,35 @@ public class OpenInvCommand implements TabExecutor {

    @Override
    public boolean onCommand(@NotNull final CommandSender sender, @NotNull final Command command, @NotNull final String label, @NotNull final String[] args) {
-        if (!(sender instanceof Player)) {
+        boolean openInv = command.getName().equals("openinv");
+
+        if (openInv && args.length > 0 && (args[0].equalsIgnoreCase("help") || args[0].equals("?"))) {
+            this.showHelp(sender);
+            return true;
+        }
+
+        if (!(sender instanceof Player player)) {
            plugin.sendMessage(sender, "messages.error.consoleUnsupported");
            return true;
        }

-        if (args.length > 0 && (args[0].equalsIgnoreCase("help") || args[0].equals("?"))) {
-            this.plugin.showHelp((Player) sender);
-            return true;
-        }
+        String noArgValue;
+        if (plugin.noArgsOpensSelf()) {
+            noArgValue = player.getUniqueId().toString();
+        } else {
+            // History management
+            noArgValue = (openInv ? this.openInvHistory : this.openEnderHistory).get(player);

-        final Player player = (Player) sender;
-        final boolean openinv = command.getName().equals("openinv");
-
-        // History management
-        String history = (openinv ? this.openInvHistory : this.openEnderHistory).get(player);
-
-        if (history == null || history.isEmpty()) {
-            history = player.getName();
-            (openinv ? this.openInvHistory : this.openEnderHistory).put(player, history);
+            if (noArgValue == null || noArgValue.isEmpty()) {
+                noArgValue = player.getUniqueId().toString();
+                (openInv ? this.openInvHistory : this.openEnderHistory).put(player, noArgValue);
+            }
        }

        final String name;

-        // Read from history if target is not named
        if (args.length < 1) {
-            name = history;
+            name = noArgValue;
        } else {
            name = args[0];
        }
@@ -89,7 +95,7 @@ public class OpenInvCommand implements TabExecutor {
                        if (!player.isOnline()) {
                            return;
                        }
-                        OpenInvCommand.this.openInventory(player, offlinePlayer, openinv);
+                        OpenInvCommand.this.openInventory(player, offlinePlayer, openInv);
                    }
                }.runTask(OpenInvCommand.this.plugin);

@@ -99,12 +105,40 @@ public class OpenInvCommand implements TabExecutor {
        return true;
    }

+    private void showHelp(final CommandSender sender) {
+        // Get registered commands
+        for (String commandName : plugin.getDescription().getCommands().keySet()) {
+            PluginCommand command = plugin.getCommand(commandName);
+
+            // Ensure command is successfully registered and sender can use it
+            if (command == null  || !command.testPermissionSilent(sender)) {
+                continue;
+            }
+
+            // Send usage
+            sender.sendMessage(command.getUsage().replace("<command>", commandName));
+
+            List<String> aliases = command.getAliases();
+            if (!aliases.isEmpty()) {
+                // Assemble alias list
+                StringJoiner aliasJoiner = new StringJoiner(", ", "   (aliases: ", ")");
+                for (String alias : aliases) {
+                    aliasJoiner.add(alias);
+                }
+
+                // Send all aliases
+                sender.sendMessage(aliasJoiner.toString());
+            }
+
+        }
+    }
+
    private void openInventory(final Player player, final OfflinePlayer target, boolean openinv) {
        Player onlineTarget;
        boolean online = target.isOnline();

        if (!online) {
-            if (Permissions.OPENOFFLINE.hasPermission(player)) {
+            if (!plugin.disableOfflineAccess() && Permissions.OPENOFFLINE.hasPermission(player)) {
                // Try loading the player's data
                onlineTarget = this.plugin.loadPlayer(target);
            } else {
@@ -142,22 +176,28 @@ public class OpenInvCommand implements TabExecutor {
            // Protected check
            if (!Permissions.OVERRIDE.hasPermission(player)
                    && Permissions.EXEMPT.hasPermission(onlineTarget)) {
-                plugin.sendMessage(player, "messages.error.permissionExempt",
-                        "%target%", onlineTarget.getDisplayName());
+                plugin.sendMessage(
+                        player,
+                        "messages.error.permissionExempt",
+                        new Replacement("%target%", onlineTarget.getDisplayName()));
                return;
            }

            // Crossworld check
            if (!Permissions.CROSSWORLD.hasPermission(player)
                    && !onlineTarget.getWorld().equals(player.getWorld())) {
-                plugin.sendMessage(player, "messages.error.permissionCrossWorld",
-                        "%target%", onlineTarget.getDisplayName());
+                plugin.sendMessage(
+                        player,
+                        "messages.error.permissionCrossWorld",
+                        new Replacement("%target%", onlineTarget.getDisplayName()));
                return;
            }
        }

-        // Record the target
-        (openinv ? this.openInvHistory : this.openEnderHistory).put(player, this.plugin.getPlayerID(target));
+        if (!plugin.noArgsOpensSelf()) {
+            // Record the target
+            (openinv ? this.openInvHistory : this.openEnderHistory).put(player, target.getUniqueId().toString());
+        }

        // Create the inventory
        final ISpecialInventory inv;
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -18,6 +18,7 @@ package com.lishid.openinv.commands;

 import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.util.TabCompleter;
+import com.lishid.openinv.util.lang.Replacement;
 import java.util.Collections;
 import java.util.List;
 import org.bukkit.Chunk;
@@ -44,7 +45,7 @@ public class SearchContainerCommand implements TabExecutor {

    @Override
    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
-        if (!(sender instanceof Player)) {
+        if (!(sender instanceof Player senderPlayer)) {
            plugin.sendMessage(sender, "messages.error.consoleUnsupported");
            return true;
        }
@@ -57,7 +58,10 @@ public class SearchContainerCommand implements TabExecutor {
        Material material = Material.getMaterial(args[0].toUpperCase());

        if (material == null) {
-            plugin.sendMessage(sender, "messages.error.invalidMaterial", "%target%", args[0]);
+            plugin.sendMessage(
+                    sender,
+                    "messages.error.invalidMaterial",
+                    new Replacement("%target%", args[0]));
            return false;
        }

@@ -72,7 +76,10 @@ public class SearchContainerCommand implements TabExecutor {
            }
        }

-        Player senderPlayer = (Player) sender;
+        // Clamp radius.
+        int configMax = plugin.getConfig().getInt("settings.command.searchcontainer.max-radius", 10);
+        radius = Math.max(0, Math.min(radius, configMax));
+
        World world = senderPlayer.getWorld();
        Chunk centerChunk = senderPlayer.getLocation().getChunk();
        StringBuilder locations = new StringBuilder();
@@ -84,10 +91,9 @@ public class SearchContainerCommand implements TabExecutor {
                }
                Chunk chunk = world.getChunkAt(centerChunk.getX() + dX, centerChunk.getZ() + dZ);
                for (BlockState tileEntity : chunk.getTileEntities()) {
-                    if (!(tileEntity instanceof InventoryHolder)) {
+                    if (!(tileEntity instanceof InventoryHolder holder)) {
                        continue;
                    }
-                    InventoryHolder holder = (InventoryHolder) tileEntity;
                    if (!holder.getInventory().contains(material)) {
                        continue;
                    }
@@ -102,13 +108,18 @@ public class SearchContainerCommand implements TabExecutor {
        if (locations.length() > 0) {
            locations.delete(locations.length() - 2, locations.length());
        } else {
-            plugin.sendMessage(sender, "messages.info.container.noMatches",
-                    "%target%", material.name());
+            plugin.sendMessage(
+                    sender,
+                    "messages.info.container.noMatches",
+                    new Replacement("%target%", material.name()));
            return true;
        }

-        plugin.sendMessage(sender, "messages.info.container.matches",
-                "%target%", material.name(), "%detail%", locations.toString());
+        plugin.sendMessage(
+                sender,
+                "messages.info.container.matches",
+                new Replacement("%target%", material.name()),
+                new Replacement("%detail%", locations.toString()));
        return true;
    }

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -18,6 +18,7 @@ package com.lishid.openinv.commands;

 import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.util.TabCompleter;
+import com.lishid.openinv.util.lang.Replacement;
 import java.util.Collections;
 import java.util.List;
 import org.bukkit.Material;
@@ -114,20 +115,23 @@ public class SearchEnchantCommand implements TabExecutor {
            // Matches found, delete trailing comma and space
            players.delete(players.length() - 2, players.length());
        } else {
-            plugin.sendMessage(sender, "messages.info.player.noMatches",
-                    "%target%", (enchant != null ? enchant.getKey().toString() : "") + " >= " + level);
+            plugin.sendMessage(
+                    sender,
+                    "messages.info.player.noMatches",
+                    new Replacement("%target%", (enchant != null ? enchant.getKey().toString() : "") + " >= " + level));
            return true;
        }

-        plugin.sendMessage(sender, "messages.info.player.matches",
-                "%target%", (enchant != null ? enchant.getKey().toString() : "") + " >= " + level,
-                "%detail%", players.toString());
+        plugin.sendMessage(
+                sender,
+                "messages.info.player.matches",
+                new Replacement("%target%", (enchant != null ? enchant.getKey().toString() : "") + " >= " + level),
+                        new Replacement("%detail%", players.toString()));
        return true;
    }

    private boolean containsEnchantment(Inventory inventory, @Nullable Enchantment enchant, int minLevel) {
        for (ItemStack item : inventory.getContents()) {
-            //noinspection ConstantConditions // Spigot improperly annotated, should be ItemStack @NotNull []
            if (item == null || item.getType() == Material.AIR) {
                continue;
            }
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -18,6 +18,7 @@ package com.lishid.openinv.commands;

 import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.util.TabCompleter;
+import com.lishid.openinv.util.lang.Replacement;
 import java.util.Collections;
 import java.util.List;
 import org.bukkit.Material;
@@ -46,7 +47,10 @@ public class SearchInvCommand implements TabExecutor {
        }

        if (material == null) {
-            plugin.sendMessage(sender, "messages.error.invalidMaterial", "%target%", args.length > 0 ? args[0] : "null");
+            plugin.sendMessage(
+                    sender,
+                    "messages.error.invalidMaterial",
+                    new Replacement("%target%", args.length > 0 ? args[0] : "null"));
            return false;
        }

@@ -56,7 +60,10 @@ public class SearchInvCommand implements TabExecutor {
            try {
                count = Integer.parseInt(args[1]);
            } catch (NumberFormatException ex) {
-                plugin.sendMessage(sender, "messages.error.invalidNumber", "%target%", args[1]);
+                plugin.sendMessage(
+                        sender,
+                        "messages.error.invalidNumber",
+                        new Replacement("%target%", args[1]));
                return false;
            }
        }
@@ -74,13 +81,18 @@ public class SearchInvCommand implements TabExecutor {
        if (players.length() > 0) {
            players.delete(players.length() - 2, players.length());
        } else {
-            plugin.sendMessage(sender, "messages.info.player.noMatches",
-                    "%target%", material.name());
+            plugin.sendMessage(
+                    sender,
+                    "messages.info.player.noMatches",
+                    new Replacement("%target%", material.name()));
            return true;
        }

-        plugin.sendMessage(sender, "messages.info.player.matches",
-                "%target%", material.name(), "%detail%", players.toString());
+        plugin.sendMessage(
+                sender,
+                "messages.info.player.matches",
+                new Replacement("%target%", material.name()),
+                new Replacement("%detail%", players.toString()));
        return true;
    }

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,8 @@
 package com.lishid.openinv.internal;

 import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.util.lang.Replacement;
+import java.util.Objects;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryType;
@@ -26,13 +28,17 @@ import org.jetbrains.annotations.NotNull;

 public class OpenInventoryView extends InventoryView {

-    private final Player player;
-    private final ISpecialInventory inventory;
-    private final String titleKey;
-    private final String titleDefaultSuffix;
+    private final @NotNull Player player;
+    private final @NotNull ISpecialInventory inventory;
+    private final @NotNull String titleKey;
+    private final @NotNull String titleDefaultSuffix;
    private String title;

-    public OpenInventoryView(Player player, ISpecialInventory inventory, String titleKey, String titleDefaultSuffix) {
+    public OpenInventoryView(
+            @NotNull Player player,
+            @NotNull ISpecialInventory inventory,
+            @NotNull String titleKey,
+            @NotNull String titleDefaultSuffix) {
        this.player = player;
        this.inventory = inventory;
        this.titleKey = titleKey;
@@ -66,18 +72,23 @@ public class OpenInventoryView extends InventoryView {

            String localTitle = OpenInv.getPlugin(OpenInv.class)
                    .getLocalizedMessage(
-                            owner,
+                            player,
                            titleKey,
-                            "%player%",
-                            owner.getName());
-            if (localTitle != null) {
-                title = localTitle;
-            } else  {
-                title = owner.getName() + titleDefaultSuffix;
-            }
+                            new Replacement("%player%", owner.getName()));
+            title = Objects.requireNonNullElseGet(localTitle, () -> owner.getName() + titleDefaultSuffix);
        }

        return title;
    }

+    @Override
+    public @NotNull String getOriginalTitle() {
+        return getTitle();
+    }
+
+    @Override
+    public void setTitle(@NotNull String title) {
+        this.title = title;
+    }
+
 }
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.listeners;
-
-import com.lishid.openinv.OpenInv;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.server.PluginDisableEvent;
-
-/**
- * Listener for plugin-related events.
- *
- * @author Jikoo
- */
-public class PluginListener implements Listener {
-
-    private final OpenInv plugin;
-
-    public PluginListener(OpenInv plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler
-    public void onPluginDisable(PluginDisableEvent event) {
-        plugin.releaseAllPlayers(event.getPlugin());
-    }
-
-}
@@ -1,187 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.util;
-
-import com.google.common.collect.Multimap;
-import com.google.common.collect.TreeMultimap;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-/**
- * A minimal thread-safe time-based cache implementation backed by a HashMap and TreeMultimap.
- *
- * @author Jikoo
- */
-public class Cache<K, V> {
-
-    private final Map<K, V> internal;
-    private final Multimap<Long, K> expiry;
-    private final long retention;
-    private final Predicate<V> inUseCheck;
-    private final Consumer<V> postRemoval;
-
-    /**
-     * Constructs a Cache with the specified retention duration, in use function, and post-removal function.
-     *
-     * @param retention duration after which keys are automatically invalidated if not in use
-     * @param inUseCheck Predicate used to check if a key is considered in use
-     * @param postRemoval Consumer used to perform any operations required when a key is invalidated
-     */
-    public Cache(final long retention, final Predicate<V> inUseCheck, final Consumer<V> postRemoval) {
-        this.internal = new HashMap<>();
-
-        this.expiry = TreeMultimap.create(Long::compareTo, (k1, k2) -> Objects.equals(k1, k2) ? 0 : 1);
-
-        this.retention = retention;
-        this.inUseCheck = inUseCheck;
-        this.postRemoval = postRemoval;
-    }
-
-    /**
-     * Set a key and value pair. Keys are unique. Using an existing key will cause the old value to
-     * be overwritten and the expiration timer to be reset.
-     *
-     * @param key key with which the specified value is to be associated
-     * @param value value to be associated with the specified key
-     */
-    public void put(final K key, final V value) {
-        // Invalidate key - runs lazy check and ensures value won't be cleaned up early
-        this.invalidate(key);
-
-        synchronized (this.internal) {
-            this.internal.put(key, value);
-            this.expiry.put(System.currentTimeMillis() + this.retention, key);
-        }
-    }
-
-    /**
-     * Returns the value to which the specified key is mapped, or null if no value is mapped for the key.
-     *
-     * @param key the key whose associated value is to be returned
-     * @return the value to which the specified key is mapped, or null if no value is mapped for the key
-     */
-    public V get(final K key) {
-        // Run lazy check to clean cache
-        this.lazyCheck();
-
-        synchronized (this.internal) {
-            return this.internal.get(key);
-        }
-    }
-
-    /**
-     * Returns true if the specified key is mapped to a value.
-     *
-     * @param key key to check if a mapping exists for
-     * @return true if a mapping exists for the specified key
-     */
-    public boolean containsKey(final K key) {
-        // Run lazy check to clean cache
-        this.lazyCheck();
-
-        synchronized (this.internal) {
-            return this.internal.containsKey(key);
-        }
-    }
-
-    /**
-     * Forcibly invalidates a key, even if it is considered to be in use.
-     *
-     * @param key key to invalidate
-     */
-    public void invalidate(final K key) {
-        // Run lazy check to clean cache
-        this.lazyCheck();
-
-        synchronized (this.internal) {
-            if (!this.internal.containsKey(key)) {
-                // Value either not present or cleaned by lazy check. Either way, we're good
-                return;
-            }
-
-            // Remove stored object
-            this.internal.remove(key);
-
-            // Remove expiration entry - prevents more work later, plus prevents issues with values invalidating early
-            for (Iterator<Map.Entry<Long, K>> iterator = this.expiry.entries().iterator(); iterator.hasNext();) {
-                if (key.equals(iterator.next().getValue())) {
-                    iterator.remove();
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     * Forcibly invalidates all keys, even if they are considered to be in use.
-     */
-    public void invalidateAll() {
-        synchronized (this.internal) {
-            for (V value : this.internal.values()) {
-                this.postRemoval.accept(value);
-            }
-            this.expiry.clear();
-            this.internal.clear();
-        }
-    }
-
-    /**
-     * Invalidate all expired keys that are not considered in use. If a key is expired but is
-     * considered in use by the provided Function, its expiration time is reset.
-     */
-    private void lazyCheck() {
-        long now = System.currentTimeMillis();
-        synchronized (this.internal) {
-            List<K> inUse = new ArrayList<>();
-            for (Iterator<Map.Entry<Long, K>> iterator = this.expiry.entries().iterator(); iterator
-                    .hasNext();) {
-                Map.Entry<Long, K> entry = iterator.next();
-
-                if (entry.getKey() > now) {
-                    break;
-                }
-
-                iterator.remove();
-
-                if (this.inUseCheck.test(this.internal.get(entry.getValue()))) {
-                    inUse.add(entry.getValue());
-                    continue;
-                }
-
-                V value = this.internal.remove(entry.getValue());
-
-                if (value == null) {
-                    continue;
-                }
-
-                this.postRemoval.accept(value);
-            }
-
-            long nextExpiry = now + this.retention;
-            for (K value : inUse) {
-                this.expiry.put(nextExpiry, value);
-            }
-        }
-    }
-
-}
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -25,13 +25,7 @@ import java.util.Set;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.configuration.ConfigurationSection;

-public class ConfigUpdater {
-
-    private final OpenInv plugin;
-
-    public ConfigUpdater(OpenInv plugin) {
-        this.plugin = plugin;
-    }
+public record ConfigUpdater(OpenInv plugin) {

    public void checkForUpdates() {
        final int version = plugin.getConfig().getInt("config-version", 1);
@@ -60,6 +54,12 @@ public class ConfigUpdater {
            if (version < 4) {
                updateConfig3To4();
            }
+            if (version < 5) {
+                updateConfig4To5();
+            }
+            if (version < 6) {
+                updateConfig5To6();
+            }

            plugin.getServer().getScheduler().runTask(plugin, () -> {
                plugin.saveConfig();
@@ -68,6 +68,21 @@ public class ConfigUpdater {
        });
    }

+    private void updateConfig5To6() {
+        plugin.getServer().getScheduler().runTask(plugin, () -> {
+            plugin.getConfig().set("settings.command.open.no-args-opens-self", false);
+            plugin.getConfig().set("settings.command.searchcontainer.max-radius", 10);
+            plugin.getConfig().set("config-version", 6);
+        });
+    }
+
+    private void updateConfig4To5() {
+        plugin.getServer().getScheduler().runTask(plugin, () -> {
+            plugin.getConfig().set("settings.disable-offline-access", false);
+            plugin.getConfig().set("config-version", 5);
+        });
+    }
+
    private void updateConfig3To4() {
        plugin.getServer().getScheduler().runTask(plugin, () -> {
            plugin.getConfig().set("notify", null);
@@ -124,7 +139,7 @@ public class ConfigUpdater {
        for (String playerName : keys) {
            OfflinePlayer player = plugin.matchPlayer(playerName);
            if (player != null) {
-                toggles.put(plugin.getPlayerID(player), section.getBoolean(playerName + ".toggle", false));
+                toggles.put(player.getUniqueId().toString(), section.getBoolean(playerName + ".toggle", false));
            }
        }

@@ -1,170 +0,0 @@
-/*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.util;
-
-import com.lishid.openinv.OpenInv;
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.logging.Level;
-import org.bukkit.ChatColor;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * A simple language manager supporting both custom and bundled languages.
- *
- * @author Jikoo
- */
-public class LanguageManager {
-
-	private final OpenInv plugin;
-	private final String defaultLocale;
-	private final Map<String, YamlConfiguration> locales;
-
-	public LanguageManager(@NotNull OpenInv plugin, @NotNull String defaultLocale) {
-		this.plugin = plugin;
-		this.defaultLocale = defaultLocale;
-		this.locales = new HashMap<>();
-		getOrLoadLocale(defaultLocale);
-	}
-
-	private YamlConfiguration getOrLoadLocale(@NotNull String locale) {
-		YamlConfiguration loaded = locales.get(locale);
-		if (loaded != null) {
-			return loaded;
-		}
-
-		InputStream resourceStream = plugin.getResource(locale + ".yml");
-		YamlConfiguration localeConfigDefaults;
-		if (resourceStream == null) {
-			localeConfigDefaults = new YamlConfiguration();
-		} else {
-			try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceStream))) {
-				localeConfigDefaults = YamlConfiguration.loadConfiguration(reader);
-			} catch (IOException e) {
-				plugin.getLogger().log(Level.WARNING, "[LanguageManager] Unable to load resource " + locale + ".yml", e);
-				localeConfigDefaults = new YamlConfiguration();
-			}
-		}
-
-		File file = new File(plugin.getDataFolder(), locale + ".yml");
-		YamlConfiguration localeConfig;
-
-		if (!file.exists()) {
-			localeConfig = localeConfigDefaults;
-			try {
-				localeConfigDefaults.save(file);
-			} catch (IOException e) {
-				plugin.getLogger().log(Level.WARNING, "[LanguageManager] Unable to save resource " + locale + ".yml", e);
-			}
-		} else {
-			localeConfig = YamlConfiguration.loadConfiguration(file);
-
-			// Add new language keys
-			List<String> newKeys = new ArrayList<>();
-			for (String key : localeConfigDefaults.getKeys(true)) {
-				if (localeConfigDefaults.isConfigurationSection(key)) {
-					continue;
-				}
-
-				if (localeConfig.isSet(key)) {
-					continue;
-				}
-
-				localeConfig.set(key, localeConfigDefaults.get(key));
-				newKeys.add(key);
-			}
-
-			if (!newKeys.isEmpty()) {
-				plugin.getLogger().info("[LanguageManager] Added new language keys: " + String.join(", ", newKeys));
-				try {
-					localeConfig.save(file);
-				} catch (IOException e) {
-					plugin.getLogger().log(Level.WARNING, "[LanguageManager] Unable to save resource " + locale + ".yml", e);
-				}
-			}
-		}
-
-		if (!locale.equals(defaultLocale)) {
-			localeConfigDefaults = locales.get(defaultLocale);
-
-			// Check for missing keys
-			List<String> newKeys = new ArrayList<>();
-			for (String key : localeConfigDefaults.getKeys(true)) {
-				if (localeConfigDefaults.isConfigurationSection(key)) {
-					continue;
-				}
-
-				if (localeConfig.isSet(key)) {
-					continue;
-				}
-
-				newKeys.add(key);
-			}
-
-			if (!newKeys.isEmpty()) {
-				plugin.getLogger().info("[LanguageManager] Missing translations from " + locale + ".yml: " + String.join(", ", newKeys));
-			}
-
-			// Fall through to default locale
-			localeConfig.setDefaults(localeConfigDefaults);
-		}
-
-		locales.put(locale, localeConfig);
-		return localeConfig;
-	}
-
-	@Nullable
-	public String getValue(@NotNull String key, @Nullable String locale) {
-		String value = getOrLoadLocale(locale == null ? defaultLocale : locale.toLowerCase()).getString(key);
-		if (value == null || value.isEmpty()) {
-			return null;
-		}
-
-		value = ChatColor.translateAlternateColorCodes('&', value);
-
-		return value;
-	}
-
-	@Nullable
-	public String getValue(@NotNull String key, @Nullable String locale, @NotNull String... replacements) {
-		if (replacements.length % 2 != 0) {
-			plugin.getLogger().log(Level.WARNING, "[LanguageManager] Replacement data is uneven", new Exception());
-		}
-
-		String value = getValue(key, locale);
-
-		if (value == null) {
-			return null;
-		}
-
-		for (int i = 0; i < replacements.length; i += 2) {
-			value = value.replace(replacements[i], replacements[i + 1]);
-		}
-
-		return value;
-	}
-
-}
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2021 lishid. All rights reserved.
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@
 package com.lishid.openinv.util;

 import org.bukkit.permissions.Permissible;
+import org.jetbrains.annotations.NotNull;

 public enum Permissions {

@@ -50,7 +51,7 @@ public enum Permissions {
        this.uninheritable = uninheritable;
    }

-    public boolean hasPermission(Permissible permissible) {
+    public boolean hasPermission(@NotNull Permissible permissible) {

        boolean hasPermission = permissible.hasPermission(permission);
        if (uninheritable || hasPermission || permissible.isPermissionSet(permission)) {
@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.util.lang;
+
+import com.lishid.openinv.OpenInv;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
+import java.util.logging.Level;
+import org.bukkit.ChatColor;
+import org.bukkit.configuration.Configuration;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A simple language manager supporting both custom and bundled languages.
+ *
+ * @author Jikoo
+ */
+public class LanguageManager {
+
+    private final OpenInv plugin;
+    private final String defaultLocale;
+    private final Map<String, YamlConfiguration> locales;
+
+    public LanguageManager(@NotNull OpenInv plugin, @NotNull String defaultLocale) {
+        this.plugin = plugin;
+        this.defaultLocale = defaultLocale;
+        this.locales = new HashMap<>();
+        getOrLoadLocale(defaultLocale);
+    }
+
+    private @NotNull YamlConfiguration getOrLoadLocale(@NotNull String locale) {
+        YamlConfiguration loaded = locales.get(locale);
+        if (loaded != null) {
+            return loaded;
+        }
+
+        File file = new File(plugin.getDataFolder(), locale + ".yml");
+
+        // Load locale config from disk and bundled locale defaults.
+        YamlConfiguration localeConfig = loadLocale(locale, file);
+
+        // If the locale is not the default locale, also handle any missing translations from the default locale.
+        if (!locale.equals(defaultLocale)) {
+            addTranslationFallthrough(locale, localeConfig, file);
+
+            if (plugin.getConfig().getBoolean("settings.secret.warn-about-guess-section", true)
+                    && localeConfig.isConfigurationSection("guess")) {
+                // Warn that guess section exists. This should run once per language per server restart
+                // when accessed by a user to hint to server owners that they can make UX improvements.
+                plugin.getLogger().info(() -> "[LanguageManager] Missing translations from " + locale + ".yml! Check the guess section!");
+            }
+        }
+
+        locales.put(locale, localeConfig);
+        return localeConfig;
+    }
+
+    private @NotNull YamlConfiguration loadLocale(
+            @NotNull String locale,
+            @NotNull File file) {
+        // Load defaults from the plugin's bundled resources.
+        InputStream resourceStream = plugin.getResource("locale/" + locale + ".yml");
+        YamlConfiguration localeConfigDefaults;
+        if (resourceStream == null) {
+            localeConfigDefaults = new YamlConfiguration();
+        } else {
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceStream, StandardCharsets.UTF_8))) {
+                localeConfigDefaults = YamlConfiguration.loadConfiguration(reader);
+            } catch (IOException e) {
+                plugin.getLogger().log(Level.WARNING, e, () -> "[LanguageManager] Unable to load resource " + locale + ".yml");
+                localeConfigDefaults = new YamlConfiguration();
+            }
+        }
+
+        if (!file.exists()) {
+            // If the file does not exist on disk, save bundled defaults.
+            try {
+                localeConfigDefaults.save(file);
+            } catch (IOException e) {
+                plugin.getLogger().log(Level.WARNING, e, () -> "[LanguageManager] Unable to save resource " + locale + ".yml");
+            }
+            // Return loaded bundled locale.
+            return localeConfigDefaults;
+        }
+
+        // If the file does exist on disk, load it.
+        YamlConfiguration localeConfig = YamlConfiguration.loadConfiguration(file);
+        // Check for missing translations from the bundled file.
+        List<String> newKeys = getMissingKeys(localeConfigDefaults, localeConfig::isSet);
+
+        if (newKeys.isEmpty()) {
+            return localeConfig;
+        }
+
+        // Get guess section for missing keys.
+        ConfigurationSection guess = localeConfig.getConfigurationSection("guess");
+
+        for (String newKey : newKeys) {
+            // Set all missing keys to defaults.
+            localeConfig.set(newKey, localeConfigDefaults.get(newKey));
+
+            // Delete relevant guess keys in case this is a new translation.
+            if (guess != null) {
+                guess.set(newKey, null);
+            }
+        }
+
+        // If guess section is empty, delete it.
+        if (guess != null && guess.getKeys(false).isEmpty()) {
+            localeConfig.set("guess", null);
+        }
+
+        plugin.getLogger().info(() -> "[LanguageManager] Added new translation keys to " + locale + ".yml: " + String.join(", ", newKeys));
+
+        // Write new keys to disk.
+        try {
+            localeConfig.save(file);
+        } catch (IOException e) {
+            plugin.getLogger().log(Level.WARNING, e, () -> "[LanguageManager] Unable to save resource " + locale + ".yml");
+        }
+
+        return localeConfig;
+    }
+
+    private void addTranslationFallthrough(
+            @NotNull String locale,
+            @NotNull YamlConfiguration localeConfig,
+            @NotNull File file) {
+        YamlConfiguration defaultLocaleConfig = locales.get(defaultLocale);
+
+        // Get missing keys. Keys that already have a guess value are not new and don't need to trigger another write.
+        List<String> missingKeys = getMissingKeys(
+                defaultLocaleConfig,
+                key -> localeConfig.isSet(key) || localeConfig.isSet("guess." + key));
+
+        if (!missingKeys.isEmpty()) {
+            // Set up guess section for missing keys.
+            for (String key : missingKeys) {
+                localeConfig.set("guess." + key, defaultLocaleConfig.get(key));
+            }
+
+            // Write modified guess section to disk.
+            try {
+                localeConfig.save(file);
+            } catch (IOException e) {
+                plugin.getLogger().log(Level.WARNING, e, () -> "[LanguageManager] Unable to save resource " + locale + ".yml");
+            }
+        }
+
+        // Fall through to default locale.
+        localeConfig.setDefaults(defaultLocaleConfig);
+    }
+
+    private @NotNull List<String> getMissingKeys(
+            @NotNull Configuration configurationDefault,
+            @NotNull Predicate<String> nodeSetPredicate) {
+        List<String> missingKeys = new ArrayList<>();
+        for (String key : configurationDefault.getKeys(true)) {
+            if (!configurationDefault.isConfigurationSection(key) && !nodeSetPredicate.test(key)) {
+                // Missing keys are non-section keys that fail the predicate.
+                missingKeys.add(key);
+            }
+        }
+        return missingKeys;
+    }
+
+    public @Nullable String getValue(@NotNull String key, @Nullable String locale) {
+        String value = getOrLoadLocale(locale == null ? defaultLocale : locale.toLowerCase()).getString(key);
+        if (value == null || value.isEmpty()) {
+            return null;
+        }
+
+        value = ChatColor.translateAlternateColorCodes('&', value);
+
+        return value;
+    }
+
+    public @Nullable String getValue(@NotNull String key, @Nullable String locale, Replacement @NotNull ... replacements) {
+        String value = getValue(key, locale);
+
+        if (value == null) {
+            return null;
+        }
+
+        for (Replacement replacement : replacements) {
+            value = value.replace(replacement.placeholder(), replacement.value());
+        }
+
+        return value;
+    }
+
+}
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2011-2022 lishid. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.util.lang;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A data holder for string replacement in translations.
+ *
+ * @param placeholder the placeholder to be replaced
+ * @param value the value to insert
+ */
+public record Replacement(@NotNull String placeholder, @NotNull String value) {
+
+}
@@ -1,4 +1,10 @@
-config-version: 4
+config-version: 6
 settings:
+  command:
+    open:
+      no-args-opens-self: false
+    searchcontainer:
+      max-radius: 30
+  disable-offline-access: false
  disable-saving: false
  locale: 'en_us'
@@ -1,6 +1,6 @@
 messages:
  error:
-    consoleUnsupported: 'You cannot use this command from console.'
+    consoleUnsupported: You cannot use this command from console.
    lootNotGenerated: '&cLoot not generated! Please disable &b/silentcontainer&c.'
    invalidMaterial: '&cInvalid material: "%target%"'
    invalidNumber: '&cInvalid number: "%target%"'
@@ -9,22 +9,24 @@ messages:
    permissionEnderAll: '&cYou''re not allowed to access other players'' ender chests.'
    permissionExempt: '&c%target%''s inventory is protected.'
    permissionCrossWorld: '&c%target% is not in your world.'
-    permissionPlayerOnline: '&cYou''re not allowed to open the inventory of online players.'
-    permissionPlayerOffline: '&cYou''re not allowed to open the inventory of offline players.'
+    permissionPlayerOnline: '&cYou''re not allowed to open the inventory of online
+      players.'
+    permissionPlayerOffline: '&cYou''re not allowed to open the inventory of offline
+      players.'
    commandException: '&cAn error occurred. Please check console for details.'
  info:
-    containerBlocked: 'You are opening a blocked container.'
-    containerBlockedSilent: 'You are opening a blocked container silently.'
-    containerSilent: 'You are opening a container silently.'
+    containerBlocked: You are opening a blocked container.
+    containerBlockedSilent: You are opening a blocked container silently.
+    containerSilent: You are opening a container silently.
    settingState: '%setting%: %state%'
    player:
-      noMatches: 'No players found with %target%.'
+      noMatches: No players found with %target%.
      matches: 'Players holding %target%: %detail%'
    container:
-      noMatches: 'No containers found with %target%.'
+      noMatches: No containers found with %target%.
      matches: 'Containers holding %target%: %detail%'
-    on: 'on'
-    off: 'off'
+    'true': 'on'
+    'false': 'off'
 container:
  player: '%player%''s Inventory'
  enderchest: '%player%''s Ender Chest'
@@ -1,11 +1,12 @@
 name: OpenInv
 main: com.lishid.openinv.OpenInv
-version: ${project.version}
+version: ${version}
 author: lishid
 authors: [Jikoo, ShadowRanger]
 description: >
             This plugin allows you to open a player's inventory as a chest and interact with it in real time.
-api-version: "1.16"
+api-version: "${apiVersion}"
+softdepend: [Utilities-OG]

 permissions:
  OpenInv.any.default:
@@ -1,146 +0,0 @@
-<!--
-  ~ Copyright (C) 2011-2021 lishid. All rights reserved.
-  ~
-  ~ This program is free software: you can redistribute it and/or modify
-  ~ it under the terms of the GNU General Public License as published by
-  ~ the Free Software Foundation, version 3.
-  ~
-  ~ 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 General Public License for more details.
-  ~
-  ~ You should have received a copy of the GNU General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <groupId>com.lishid</groupId>
-  <artifactId>openinvparent</artifactId>
-  <name>OpenInv</name>
-  <url>http://dev.bukkit.org/bukkit-plugins/openinv/</url>
-  <version>4.1.9-SNAPSHOT</version>
-
-  <packaging>pom</packaging>
-
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.source>1.8</maven.compiler.source>
-    <maven.compiler.target>1.8</maven.compiler.target>
-  </properties>
-
-  <profiles>
-    <profile>
-      <id>all</id>
-      <modules>
-        <module>api</module>
-        <module>plugin</module>
-        <module>internal/v1_16_R3</module>
-        <module>internal/v1_17_R1</module>
-        <module>assembly</module>
-      </modules>
-    </profile>
-
-    <profile>
-      <id>default</id>
-      <activation>
-        <activeByDefault>true</activeByDefault>
-      </activation>
-      <modules>
-        <module>api</module>
-        <module>plugin</module>
-        <module>assembly</module>
-      </modules>
-    </profile>
-  </profiles>
-
-  <repositories>
-    <repository>
-      <id>spigot-repo</id>
-      <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
-    </repository>
-  </repositories>
-
-  <dependencyManagement>
-    <dependencies>
-      <dependency>
-        <artifactId>annotations</artifactId>
-        <groupId>org.jetbrains</groupId>
-        <scope>provided</scope>
-        <version>21.0.1</version>
-      </dependency>
-      <dependency>
-        <artifactId>spigot-api</artifactId>
-        <groupId>org.spigotmc</groupId>
-        <scope>provided</scope>
-        <version>1.16.5-R0.1-SNAPSHOT</version>
-      </dependency>
-      <dependency>
-        <artifactId>openinvapi</artifactId>
-        <groupId>com.lishid</groupId>
-        <scope>compile</scope>
-        <version>4.1.9-SNAPSHOT</version>
-      </dependency>
-      <dependency>
-        <artifactId>openinvplugincore</artifactId>
-        <groupId>com.lishid</groupId>
-        <scope>compile</scope>
-        <version>4.1.9-SNAPSHOT</version>
-      </dependency>
-    </dependencies>
-  </dependencyManagement>
-
-  <build>
-    <pluginManagement>
-      <plugins>
-        <plugin>
-          <artifactId>maven-shade-plugin</artifactId>
-          <configuration>
-            <filters>
-              <filter>
-                <!-- Always shade entirety of required modules. -->
-                <artifact>com.lishid:openinv*</artifact>
-                <includes>
-                  <include>**</include>
-                </includes>
-              </filter>
-              <filter>
-                <artifact>*:*</artifact>
-                <!-- Don't warn about file conflicts that'll be clobbered anyway. -->
-                <excludes>
-                  <exclude>META-INF/MANIFEST.MF</exclude>
-                </excludes>
-              </filter>
-            </filters>
-            <minimizeJar>true</minimizeJar>
-          </configuration>
-          <executions>
-            <execution>
-              <phase>package</phase>
-              <goals>
-                <goal>shade</goal>
-              </goals>
-            </execution>
-          </executions>
-          <groupId>org.apache.maven.plugins</groupId>
-          <version>3.2.4</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-compiler-plugin</artifactId>
-          <groupId>org.apache.maven.plugins</groupId>
-          <version>3.8.1</version>
-        </plugin>
-
-        <plugin>
-          <artifactId>maven-assembly-plugin</artifactId>
-          <groupId>org.apache.maven.plugins</groupId>
-          <version>3.3.0</version>
-        </plugin>
-      </plugins>
-    </pluginManagement>
-  </build>
-
-</project>
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (C) 2011-2021 lishid. All rights reserved.
+# Copyright (C) 2011-2023 lishid. All rights reserved.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -36,7 +36,7 @@ function get_minecraft_versions() {

  for version in "${versions[@]}"; do
    # Append comma if variable is set, then append version
-    minecraft_versions="${minecraft_versions:+${minecraft_versions},}${version%%-R*}"
+    minecraft_versions="${minecraft_versions:+${minecraft_versions}, }${version%%-R*}"
  done

  echo "${minecraft_versions}"
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (C) 2011-2021 lishid. All rights reserved.
+# Copyright (C) 2011-2022 lishid. All rights reserved.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,36 +15,38 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #

-# TODO FIGURE OUT AND REMOVE WHEN LESS STRESS
-hacky_versions=("1.16.5-R0.1-SNAPSHOT" "1.17-R0.1-SNAPSHOT")
-for hacky_version in "${hacky_versions[@]}"; do
-  echo "$hacky_version"
-done
-
-exit 0
-
 # Note that this script is designed for use in GitHub Actions, and is not
 # particularly robust nor configurable. Run from project parent directory.

+# Use a nameref as a cache - maven evaluation is pretty slow.
+# Re-calling the script and relying on it to handle caching is way easier than passing around info.
+declare -a spigot_versions
+
+# We don't care about concatenation - either it's not null and we handle entries or it's null and we instantiate.
+# shellcheck disable=SC2199
+if [[ ${spigot_versions[@]} ]]; then
+  for spigot_version in "${spigot_versions[@]}"; do
+    echo "$spigot_version"
+  done
+  return
+fi
+
+old_maven_opts=$MAVEN_OPTS
+# Add JVM parameters to allow help plugin access to packages it needs.
+export MAVEN_OPTS="$old_maven_opts --add-opens java.base/java.util=ALL-UNNAMED --add-opens java.base/java.lang.reflect=ALL-UNNAMED --add-opens java.base/java.text=ALL-UNNAMED --add-opens java.desktop/java.awt.font=ALL-UNNAMED"
+
 # Pull Spigot dependency information from Maven.
 # Since we only care about Spigot versions, only check modules in the folder internal.
 readarray -t modules <<< "$(mvn help:evaluate -Dexpression=project.modules -q -DforceStdout -P all | grep -oP '(?<=<string>)(internal/.*)(?=</string>)')"

+declare -n versions="spigot_versions"
+
 for module in "${modules[@]}"; do
-  # Get number of dependencies declared in pom of specified internal module.
-  max_index=$(mvn help:evaluate -Dexpression=project.dependencies -q -DforceStdout -P all -pl "$module" | grep -c "<dependency>")
-
-  for ((i=0; i < max_index; i++)); do
-    # Get artifactId of dependency.
-    artifact_id=$(mvn help:evaluate -Dexpression=project.dependencies["$i"].artifactId -q -DforceStdout -P all -pl "$module")
-
-    # Ensure dependency is Spigot.
-    if [[ "$artifact_id" == spigot ]]; then
-      # Get Spigot version.
-      spigot_version=$(mvn help:evaluate -Dexpression=project.dependencies["$i"].version -q -DforceStdout -P all -pl "$module")
-      versions+=("$spigot_version")
-      echo "$spigot_version"
-      break
-    fi
-  done
+  # Get Spigot version.
+  spigot_version=$(mvn help:evaluate -Dexpression=spigot.version -q -DforceStdout -P all -pl "$module")
+  versions+=("$spigot_version")
+  echo "$spigot_version"
 done
+
+# Reset JVM parameters
+export MAVEN_OPTS=$old_maven_opts
@@ -1,6 +1,6 @@
 #!/bin/bash
 #
-# Copyright (C) 2011-2021 lishid. All rights reserved.
+# Copyright (C) 2011-2022 lishid. All rights reserved.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -33,15 +33,18 @@ get_buildtools () {
 readarray -t versions <<< "$(. ./scripts/get_spigot_versions.sh)"
 echo Found Spigot dependencies: "${versions[@]}"

+# Install dependencies aside from Spigot prior to running in offline mode.
+mvn dependency:go-offline -DexcludeArtifactIds=spigot
+
 for version in "${versions[@]}"; do
  set -e
  exit_code=0
-  mvn dependency:get -Dartifact=org.spigotmc:spigot:"$version" -q -o || exit_code=$?
+  mvn dependency:get -Dartifact=org.spigotmc:spigot:"$version":remapped-mojang -q -o || exit_code=$?
  if [ $exit_code -ne 0 ]; then
    echo Installing missing Spigot version "$version"
    revision=${version%%-R*}
    get_buildtools
-    java -jar $buildtools -rev "$revision"
+    java -jar $buildtools -rev "$revision" --remapped
  else
    echo Spigot "$version" is already installed
  fi
@@ -0,0 +1,8 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        maven("https://repo.papermc.io/repository/maven-public/")
+    }
+}
+
+rootProject.name = "OpenInv"
				`@@ -0,0 +1 @@`
				`.gitea/CODEOWNERS linguist-detectable=false`