Add trace to InstantiationException

.github/workflows/ci.yml

@@ -12,10 +12,9 @@ jobs:
         uses: actions/checkout@v2
 
       - name: Set Up Java
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v1
         with:
-          distribution: 'adopt'
-          java-version: '17'
+          java-version: 16
 
       # Use cache to speed up build
       - name: Cache Maven Repo

api/src/main/java/com/lishid/openinv/internal/IAnySilentContainer.java

@@ -24,6 +24,7 @@ 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;
@@ -83,11 +84,26 @@ public interface IAnySilentContainer {
 
         // Shulker boxes require 1/2 a block clear in the direction they open.
         if (blockState instanceof ShulkerBox) {
-            if (isShulkerBlocked((ShulkerBox) blockState)) {
+            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.
                 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;
         }
@@ -124,14 +140,6 @@ public interface IAnySilentContainer {
         return isChestBlocked(relative);
     }
 
-    boolean isShulkerBlocked(ShulkerBox block);
-
-    /**
-     * Determine whether or not a chest is blocked.
-     *
-     * @param chest the chest block
-     * @return true if the chest block cannot be opened under ordinary circumstances
-     */
     default boolean isChestBlocked(Block chest) {
         org.bukkit.block.Block relative = chest.getRelative(0, 1, 0);
         return relative.getType().isOccluding()

api/src/main/java/com/lishid/openinv/util/InventoryAccess.java

@@ -20,6 +20,7 @@ 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;
@@ -80,8 +81,7 @@ public class InventoryAccess implements IInventoryAccess {
             } catch (ReflectiveOperationException ignored) {}
         }
 
-        // Use reflection to find the IInventory
-        inv = ReflectionHelper.grabObjectByType(inventory, expected);
+        inv = grabFieldOfTypeFromObject(expected, inventory);
 
         if (expected.isInstance(inv)) {
             return expected.cast(inv);
@@ -90,6 +90,23 @@ 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) {

api/src/main/java/com/lishid/openinv/util/ReflectionHelper.java

@@ -1,75 +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 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;
-    }
-
-}

internal/v1_16_R3/pom.xml

@@ -0,0 +1,64 @@
+<?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>

internal/v1_16_R3/src/main/java/com/lishid/openinv/internal/v1_16_R3/AnySilentContainer.java

@@ -0,0 +1,245 @@
+/*
+ * 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();
+        }
+    }
+
+}

internal/v1_16_R3/src/main/java/com/lishid/openinv/internal/v1_16_R3/OpenPlayer.java

@@ -0,0 +1,78 @@
+/*
+ * 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());
+        }
+    }
+
+}

internal/v1_16_R3/src/main/java/com/lishid/openinv/internal/v1_16_R3/PlayerDataManager.java

@@ -14,31 +14,30 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.lishid.openinv.internal.v1_18_R1;
+package com.lishid.openinv.internal.v1_16_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.Logger;
-import net.minecraft.network.chat.TextComponent;
-import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.entity.Entity;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-import net.minecraft.world.inventory.MenuType;
-import net.minecraft.world.level.Level;
+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_18_R1.CraftServer;
-import org.bukkit.craftbukkit.v1_18_R1.entity.CraftPlayer;
-import org.bukkit.craftbukkit.v1_18_R1.event.CraftEventFactory;
-import org.bukkit.craftbukkit.v1_18_R1.inventory.CraftContainer;
+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;
@@ -52,23 +51,22 @@ public class PlayerDataManager implements IPlayerDataManager {
         try {
             bukkitEntity = Entity.class.getDeclaredField("bukkitEntity");
         } 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(java.util.logging.Level.WARNING, e.getMessage(), 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 ServerPlayer getHandle(final Player player) {
+    public static @NotNull EntityPlayer getHandle(final Player player) {
         if (player instanceof CraftPlayer) {
             return ((CraftPlayer) player).getHandle();
         }
 
         Server server = player.getServer();
-        ServerPlayer nmsPlayer = null;
+        EntityPlayer nmsPlayer = null;
 
         if (server instanceof CraftServer) {
-            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getUniqueId());
+            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getName());
         }
 
         if (nmsPlayer == null) {
@@ -91,13 +89,13 @@ public class PlayerDataManager implements IPlayerDataManager {
         GameProfile profile = new GameProfile(offline.getUniqueId(),
                 offline.getName() != null ? offline.getName() : offline.getUniqueId().toString());
         MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
-        ServerLevel worldServer = server.getLevel(Level.OVERWORLD);
+        WorldServer worldServer = server.getWorldServer(World.OVERWORLD);
 
         if (worldServer == null) {
             return null;
         }
 
-        ServerPlayer entity = new ServerPlayer(server, worldServer, profile);
+        EntityPlayer entity = new EntityPlayer(server, worldServer, profile, new PlayerInteractManager(worldServer));
 
         try {
             injectPlayer(entity);
@@ -115,7 +113,7 @@ public class PlayerDataManager implements IPlayerDataManager {
         return target;
     }
 
-    void injectPlayer(ServerPlayer player) throws IllegalAccessException {
+    void injectPlayer(EntityPlayer player) throws IllegalAccessException {
         if (bukkitEntity == null) {
             return;
         }
@@ -129,7 +127,7 @@ public class PlayerDataManager implements IPlayerDataManager {
     @Override
     public Player inject(@NotNull Player player) {
         try {
-            ServerPlayer nmsPlayer = getHandle(player);
+            EntityPlayer nmsPlayer = getHandle(player);
             injectPlayer(nmsPlayer);
             return nmsPlayer.getBukkitEntity();
         } catch (IllegalAccessException e) {
@@ -142,9 +140,9 @@ public class PlayerDataManager implements IPlayerDataManager {
     @Override
     public InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {
 
-        ServerPlayer nmsPlayer = getHandle(player);
+        EntityPlayer nmsPlayer = getHandle(player);
 
-        if (nmsPlayer.connection == null) {
+        if (nmsPlayer.playerConnection == null) {
             return null;
         }
 
@@ -154,24 +152,24 @@ public class PlayerDataManager implements IPlayerDataManager {
             return player.openInventory(inventory.getBukkitInventory());
         }
 
-        AbstractContainerMenu container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
+        Container container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
             @Override
-            public MenuType<?> getType() {
+            public Containers<?> getType() {
                 return getContainers(inventory.getBukkitInventory().getSize());
             }
         };
 
-        container.setTitle(new TextComponent(view.getTitle()));
+        container.setTitle(new ChatComponentText(view.getTitle()));
         container = CraftEventFactory.callInventoryOpenEvent(nmsPlayer, container);
 
         if (container == null) {
             return null;
         }
 
-        nmsPlayer.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(),
-                new TextComponent(container.getBukkitView().getTitle())));
-        nmsPlayer.containerMenu = container;
-        nmsPlayer.initMenu(container);
+        nmsPlayer.playerConnection.sendPacket(new PacketPlayOutOpenWindow(container.windowId, container.getType(),
+                new ChatComponentText(container.getBukkitView().getTitle())));
+        nmsPlayer.activeContainer = container;
+        container.addSlotListener(nmsPlayer);
 
         return container.getBukkitView();
 
@@ -187,16 +185,23 @@ public class PlayerDataManager implements IPlayerDataManager {
         }
     }
 
-    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
-        };
+    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

internal/v1_16_R3/src/main/java/com/lishid/openinv/internal/v1_16_R3/SpecialEnderChest.java

@@ -0,0 +1,261 @@
+/*
+ * 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);
+        }
+
+    }
+
+}

internal/v1_16_R3/src/main/java/com/lishid/openinv/internal/v1_16_R3/SpecialPlayerInventory.java

@@ -0,0 +1,738 @@
+/*
+ * 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);
+        }
+    }
+
+}

internal/v1_17_R1/pom.xml

@@ -39,8 +39,7 @@
       <artifactId>spigot</artifactId>
       <groupId>org.spigotmc</groupId>
       <scope>provided</scope>
-      <version>1.17.1-R0.1-SNAPSHOT</version>
-      <classifier>remapped-mojang</classifier>
+      <version>1.17-R0.1-SNAPSHOT</version>
     </dependency>
     <dependency>
       <artifactId>openinvapi</artifactId>
@@ -60,45 +59,14 @@
     <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>true</minimizeJar>
+          <minimizeJar>false</minimizeJar>
         </configuration>
       </plugin>
       <plugin>
         <artifactId>maven-compiler-plugin</artifactId>
       </plugin>
-      <plugin>
-        <groupId>net.md-5</groupId>
-        <artifactId>specialsource-maven-plugin</artifactId>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>remap</goal>
-            </goals>
-            <id>remap-obf</id>
-            <configuration>
-              <srgIn>org.spigotmc:minecraft-server:1.17.1-R0.1-SNAPSHOT:txt:maps-mojang</srgIn>
-              <reverse>true</reverse>
-              <remappedDependencies>org.spigotmc:spigot:1.17.1-R0.1-SNAPSHOT:jar:remapped-mojang</remappedDependencies>
-              <remappedArtifactAttached>true</remappedArtifactAttached>
-              <remappedClassifierName>remapped-obf</remappedClassifierName>
-            </configuration>
-          </execution>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>remap</goal>
-            </goals>
-            <id>remap-spigot</id>
-            <configuration>
-              <inputFile>${project.build.directory}/${project.artifactId}-${project.version}-remapped-obf.jar</inputFile>
-              <srgIn>org.spigotmc:minecraft-server:1.17.1-R0.1-SNAPSHOT:csrg:maps-spigot</srgIn>
-              <remappedDependencies>org.spigotmc:spigot:1.17.1-R0.1-SNAPSHOT:jar:remapped-obf</remappedDependencies>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
     </plugins>
   </build>
 

internal/v1_17_R1/src/main/java/com/lishid/openinv/internal/v1_17_R1/AnySilentContainer.java

@@ -18,104 +18,57 @@ package com.lishid.openinv.internal.v1_17_R1;
 
 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.Optional;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import net.minecraft.core.BlockPos;
-import net.minecraft.network.chat.TextComponent;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.server.level.ServerPlayerGameMode;
-import net.minecraft.world.CompoundContainer;
-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.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.ChestBlock;
-import net.minecraft.world.level.block.DoubleBlockCombiner;
-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.ChestBlockEntity;
-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 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.block.ShulkerBox;
-import org.bukkit.craftbukkit.v1_17_R1.CraftWorld;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.InventoryView;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 public class AnySilentContainer implements IAnySilentContainer {
 
-    private @Nullable Field serverPlayerGameModeGameType;
+    private Field playerInteractManagerGamemode;
 
     public AnySilentContainer() {
         try {
-            try {
-                // IDE warns about field not existing, but SpecialSource does not remap strings used in reflection.
-                // The warning is not suppressed as a reminder that it must manually be checked on updates.
-                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) {
+            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 game mode! SilentContainer will fail.");
-            logger.log(Level.WARNING, "Error obtaining GameType field", e);
+            logger.warning("Unable to directly write player gamemode! SilentChest will fail.");
+            logger.log(Level.WARNING, "Error obtaining gamemode field", e);
         }
     }
 
-    @Override
-    public boolean isShulkerBlocked(ShulkerBox box) {
-        org.bukkit.World bukkitWorld = box.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(box.getX(), box.getY(), box.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,
@@ -129,109 +82,128 @@ public class AnySilentContainer implements IAnySilentContainer {
             return true;
         }
 
-        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+        EntityPlayer 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);
+        final World world = player.getWorld();
+        final BlockPosition blockPosition = new BlockPosition(bukkitBlock.getX(), bukkitBlock.getY(), bukkitBlock.getZ());
+        final TileEntity tile = world.getTileEntity(blockPosition);
 
-        if (blockEntity == null) {
+        if (tile == null) {
             return false;
         }
 
-        if (blockEntity instanceof EnderChestBlockEntity enderChestTile) {
+        if (tile instanceof TileEntityEnderChest) {
             // Anychest ender chest. See net.minecraft.world.level.block.BlockEnderChest
-            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);
-            }, new TextComponent("container.enderchest")));
+            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 (!(blockEntity instanceof MenuProvider menuProvider)) {
+        if (!(tile instanceof ITileInventory tileInventory)) {
             return false;
         }
 
-        BlockState blockState = level.getBlockState(blockPos);
-        Block block = blockState.getBlock();
+        IBlockData blockData = world.getType(blockPosition);
+        Block block = blockData.getBlock();
 
-        if (block instanceof ChestBlock chestBlock) {
+        if (block instanceof BlockChest) {
 
-            // boolean flag: check if chest is blocked
-            Optional<MenuProvider> menuOptional = chestBlock.combine(blockState, level, blockPos, false).apply(
-                    // Combiner is a copy of private ChestBlock.MENU_PROVIDER_COMBINER
-                    new DoubleBlockCombiner.Combiner<ChestBlockEntity, Optional<MenuProvider>>() {
-                        @Override
-                        public Optional<MenuProvider> acceptDouble(ChestBlockEntity localChest1, ChestBlockEntity localChest2) {
-                            CompoundContainer doubleChest = new CompoundContainer(localChest1, localChest2);
-                            return Optional.of(new ChestBlock.DoubleInventory(localChest1, localChest2, doubleChest));
+            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");
+                                }
+                            };
                         }
-
-                        @Override
-                        public Optional<MenuProvider> acceptSingle(ChestBlockEntity localChest) {
-                            return Optional.of(localChest);
-                        }
-
-                        @Override
-                        public Optional<MenuProvider> acceptNone() {
-                            return Optional.empty();
-                        }
-                    });
-
-            if (menuOptional.isEmpty()) {
-                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
-                return false;
+                    }
+                }
             }
 
-            menuProvider = menuOptional.get();
-
-            if (block instanceof TrappedChestBlock) {
+            if (block instanceof BlockChestTrapped) {
                 bukkitPlayer.incrementStatistic(Statistic.TRAPPED_CHEST_TRIGGERED);
             } else {
                 bukkitPlayer.incrementStatistic(Statistic.CHEST_OPENED);
             }
         }
 
-        if (block instanceof ShulkerBoxBlock) {
+        if (block instanceof BlockShulkerBox) {
             bukkitPlayer.incrementStatistic(Statistic.SHULKER_BOX_OPENED);
         }
 
-        if (block instanceof BarrelBlock) {
+        if (block instanceof BlockBarrel) {
             bukkitPlayer.incrementStatistic(Statistic.OPEN_BARREL);
         }
 
         // AnyChest only - SilentChest not active, container unsupported, or unnecessary.
-        if (!silentchest || player.gameMode.getGameModeForPlayer() == GameType.SPECTATOR) {
-            player.openMenu(menuProvider);
+        if (!silentchest || player.d.getGameMode() == EnumGamemode.d) {
+            player.openContainer(tileInventory);
             return true;
         }
 
-        // SilentChest requires access to setting players' game mode directly.
-        if (this.serverPlayerGameModeGameType == null) {
+        // SilentChest requires access to setting players' gamemode directly.
+        if (this.playerInteractManagerGamemode == null) {
             return false;
         }
 
-        if (blockEntity instanceof RandomizableContainerBlockEntity lootable) {
-            if (lootable.lootTable != null) {
+        if (tile instanceof TileEntityLootable lootable) {
+            if (lootable.g != 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);
+        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.serverPlayerGameModeGameType == null) {
+        if (this.playerInteractManagerGamemode == null) {
             return;
         }
 
@@ -246,29 +218,29 @@ public class AnySilentContainer implements IAnySilentContainer {
                 return;
         }
 
-        ServerPlayer player = PlayerDataManager.getHandle(bukkitPlayer);
+        EntityPlayer 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);
+        EnumGamemode gamemode = player.d.getGameMode();
+        this.forceGameMode(player, EnumGamemode.d);
 
-        // Close container - note that this is very different from ServerPlayer#closeContainer!
-        // Triggering event must not be re-called or we'll enter an infinite loop.
-        player.doCloseContainer();
+        // 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.forceGameType(player, gameType);
+        this.forceGameMode(player, gamemode);
     }
 
-    private void forceGameType(final ServerPlayer player, final GameType gameMode) {
-        if (this.serverPlayerGameModeGameType == null) {
+    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.serverPlayerGameModeGameType.setAccessible(true);
-            this.serverPlayerGameModeGameType.set(player.gameMode, gameMode);
+            this.playerInteractManagerGamemode.setAccessible(true);
+            this.playerInteractManagerGamemode.set(player.d, gameMode);
         } catch (IllegalArgumentException | IllegalAccessException e) {
             e.printStackTrace();
         }

internal/v1_17_R1/src/main/java/com/lishid/openinv/internal/v1_17_R1/OpenPlayer.java

@@ -17,25 +17,25 @@
 package com.lishid.openinv.internal.v1_17_R1;
 
 import java.io.File;
-import net.minecraft.Util;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.NbtIo;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.level.storage.PlayerDataStorage;
+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, ServerPlayer entity) {
+    public OpenPlayer(CraftServer server, EntityPlayer entity) {
         super(server, entity);
     }
 
     @Override
     public void loadData() {
         // See CraftPlayer#loadData
-        CompoundTag loaded = this.server.getHandle().playerIo.load(this.getHandle());
+        NBTTagCompound loaded = this.server.getHandle().r.load(this.getHandle());
         if (loaded != null) {
             readExtraData(loaded);
         }
@@ -43,31 +43,35 @@ public class OpenPlayer extends CraftPlayer {
 
     @Override
     public void saveData() {
-        ServerPlayer player = this.getHandle();
-        // See net.minecraft.world.level.storage.PlayerDataStorage#save(EntityHuman)
+        EntityPlayer player = this.getHandle();
+        // See net.minecraft.world.level.storage.WorldNBTStorage#save(EntityHuman)
         try {
-            PlayerDataStorage worldNBTStorage = player.server.getPlayerList().playerIo;
+            WorldNBTStorage worldNBTStorage = player.c.getPlayerList().r;
 
-            CompoundTag playerData = player.saveWithoutId(new CompoundTag());
+            NBTTagCompound playerData = player.save(new NBTTagCompound());
             setExtraData(playerData);
 
             if (!isOnline()) {
                 // Special case: save old vehicle data
-                CompoundTag oldData = worldNBTStorage.load(player);
+                NBTTagCompound oldData = worldNBTStorage.load(player);
 
-                if (oldData != null && oldData.contains("RootVehicle", 10)) {
+                if (oldData != null && oldData.hasKeyOfType("RootVehicle", 10)) {
                     // See net.minecraft.server.PlayerList#a(NetworkManager, EntityPlayer) and net.minecraft.server.EntityPlayer#b(NBTTagCompound)
-                    playerData.put("RootVehicle", oldData.getCompound("RootVehicle"));
+                    playerData.set("RootVehicle", oldData.getCompound("RootVehicle"));
                 }
             }
 
-            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);
+            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.getName().getString());
+            LogManager.getLogger().warn("Failed to save player data for {}", player.getDisplayName().getString());
         }
     }
 

internal/v1_17_R1/src/main/java/com/lishid/openinv/internal/v1_17_R1/PlayerDataManager.java

@@ -22,16 +22,17 @@ 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.TextComponent;
-import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
+import net.minecraft.network.chat.ChatComponentText;
+import net.minecraft.network.protocol.game.PacketPlayOutOpenWindow;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.level.EntityPlayer;
+import net.minecraft.server.level.WorldServer;
 import net.minecraft.world.entity.Entity;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-import net.minecraft.world.inventory.MenuType;
-import net.minecraft.world.level.Level;
+import net.minecraft.world.inventory.Container;
+import net.minecraft.world.inventory.Containers;
+import net.minecraft.world.level.World;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.Server;
@@ -54,21 +55,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(java.util.logging.Level.WARNING, e.getMessage(), e);
+            logger.log(Level.WARNING, e.getMessage(), e);
             bukkitEntity = null;
         }
     }
 
-    public static @NotNull ServerPlayer getHandle(final Player player) {
+    public static @NotNull EntityPlayer getHandle(final Player player) {
         if (player instanceof CraftPlayer) {
             return ((CraftPlayer) player).getHandle();
         }
 
         Server server = player.getServer();
-        ServerPlayer nmsPlayer = null;
+        EntityPlayer nmsPlayer = null;
 
         if (server instanceof CraftServer) {
-            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getUniqueId());
+            nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getName());
         }
 
         if (nmsPlayer == null) {
@@ -91,13 +92,13 @@ public class PlayerDataManager implements IPlayerDataManager {
         GameProfile profile = new GameProfile(offline.getUniqueId(),
                 offline.getName() != null ? offline.getName() : offline.getUniqueId().toString());
         MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
-        ServerLevel worldServer = server.getLevel(Level.OVERWORLD);
+        WorldServer worldServer = server.getWorldServer(World.f);
 
         if (worldServer == null) {
             return null;
         }
 
-        ServerPlayer entity = new ServerPlayer(server, worldServer, profile);
+        EntityPlayer entity = new EntityPlayer(server, worldServer, profile);
 
         try {
             injectPlayer(entity);
@@ -115,21 +116,21 @@ public class PlayerDataManager implements IPlayerDataManager {
         return target;
     }
 
-    void injectPlayer(ServerPlayer player) throws IllegalAccessException {
+    void injectPlayer(EntityPlayer player) throws IllegalAccessException {
         if (bukkitEntity == null) {
             return;
         }
 
         bukkitEntity.setAccessible(true);
 
-        bukkitEntity.set(player, new OpenPlayer(player.server.server, player));
+        bukkitEntity.set(player, new OpenPlayer(player.c.server, player));
     }
 
     @NotNull
     @Override
     public Player inject(@NotNull Player player) {
         try {
-            ServerPlayer nmsPlayer = getHandle(player);
+            EntityPlayer nmsPlayer = getHandle(player);
             injectPlayer(nmsPlayer);
             return nmsPlayer.getBukkitEntity();
         } catch (IllegalAccessException e) {
@@ -142,9 +143,9 @@ public class PlayerDataManager implements IPlayerDataManager {
     @Override
     public InventoryView openInventory(@NotNull Player player, @NotNull ISpecialInventory inventory) {
 
-        ServerPlayer nmsPlayer = getHandle(player);
+        EntityPlayer nmsPlayer = getHandle(player);
 
-        if (nmsPlayer.connection == null) {
+        if (nmsPlayer.b == null) {
             return null;
         }
 
@@ -154,23 +155,23 @@ public class PlayerDataManager implements IPlayerDataManager {
             return player.openInventory(inventory.getBukkitInventory());
         }
 
-        AbstractContainerMenu container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
+        Container container = new CraftContainer(view, nmsPlayer, nmsPlayer.nextContainerCounter()) {
             @Override
-            public MenuType<?> getType() {
+            public Containers<?> getType() {
                 return getContainers(inventory.getBukkitInventory().getSize());
             }
         };
 
-        container.setTitle(new TextComponent(view.getTitle()));
+        container.setTitle(new ChatComponentText(view.getTitle()));
         container = CraftEventFactory.callInventoryOpenEvent(nmsPlayer, container);
 
         if (container == null) {
             return null;
         }
 
-        nmsPlayer.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(),
-                new TextComponent(container.getBukkitView().getTitle())));
-        nmsPlayer.containerMenu = container;
+        nmsPlayer.b.sendPacket(new PacketPlayOutOpenWindow(container.j, container.getType(),
+                new ChatComponentText(container.getBukkitView().getTitle())));
+        nmsPlayer.bV = container;
         nmsPlayer.initMenu(container);
 
         return container.getBukkitView();
@@ -187,15 +188,15 @@ public class PlayerDataManager implements IPlayerDataManager {
         }
     }
 
-    static @NotNull MenuType<?> getContainers(int inventorySize) {
+    static @NotNull Containers<?> 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
+            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
         };
     }
 

internal/v1_17_R1/src/main/java/com/lishid/openinv/internal/v1_17_R1/SpecialEnderChest.java

@@ -21,38 +21,38 @@ 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.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.EnderChestBlockEntity;
+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 PlayerEnderChestContainer implements ISpecialEnderChest {
+public class SpecialEnderChest extends InventoryEnderChest implements ISpecialEnderChest {
 
     private final CraftInventory inventory;
-    private ServerPlayer owner;
-    private NonNullList<ItemStack> items;
+    private EntityPlayer owner;
+    private NonNullList<ItemStack> c;
     private boolean playerOnline;
 
-    public SpecialEnderChest(final org.bukkit.entity.Player player, final Boolean online) {
+    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.getEnderChestInventory().items;
+        this.c = this.owner.getEnderChest().c;
     }
 
     @Override
@@ -71,15 +71,15 @@ public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpe
     }
 
     @Override
-    public void setPlayerOnline(@NotNull final org.bukkit.entity.Player player) {
+    public void setPlayerOnline(@NotNull final Player player) {
         if (!this.playerOnline) {
             try {
                 this.owner = PlayerDataManager.getHandle(player);
-                PlayerEnderChestContainer enderChest = owner.getEnderChestInventory();
-                for (int i = 0; i < enderChest.getContainerSize(); ++i) {
-                    enderChest.setItem(i, this.items.get(i));
+                InventoryEnderChest enderChest = owner.getEnderChest();
+                for (int i = 0; i < enderChest.getSize(); ++i) {
+                    enderChest.setItem(i, this.c.get(i));
                 }
-                this.items = enderChest.items;
+                this.c = enderChest.c;
                 enderChest.transaction.addAll(this.transaction);
             } catch (Exception ignored) {}
             this.playerOnline = true;
@@ -87,63 +87,65 @@ public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpe
     }
 
     @Override
-    public @NotNull org.bukkit.entity.Player getPlayer() {
+    public @NotNull Player getPlayer() {
         return owner.getBukkitEntity();
     }
 
     @Override
-    public void setChanged() {
-        this.owner.getEnderChestInventory().setChanged();
+    public void update() {
+        this.owner.getEnderChest().update();
     }
 
     @Override
     public List<ItemStack> getContents() {
-        return this.items;
+        return this.c;
     }
 
     @Override
     public void onOpen(CraftHumanEntity who) {
-        this.owner.getEnderChestInventory().onOpen(who);
+        super.onOpen(who);
+        this.owner.getEnderChest().onOpen(who);
     }
 
     @Override
     public void onClose(CraftHumanEntity who) {
-        this.owner.getEnderChestInventory().onClose(who);
+        super.onClose(who);
+        this.owner.getEnderChest().onClose(who);
     }
 
     @Override
     public List<HumanEntity> getViewers() {
-        return this.owner.getEnderChestInventory().getViewers();
+        return this.owner.getEnderChest().getViewers();
     }
 
     @Override
-    public boolean stillValid(Player player) {
+    public boolean a(EntityHuman entityhuman) {
         return true;
     }
 
     @Override
-    public void setActiveChest(EnderChestBlockEntity enderChest) {
-        this.owner.getEnderChestInventory().setActiveChest(enderChest);
+    public void a(TileEntityEnderChest tileentityenderchest) {
+        this.owner.getEnderChest().a(tileentityenderchest);
     }
 
     @Override
-    public boolean isActiveChest(EnderChestBlockEntity enderChest) {
-        return this.owner.getEnderChestInventory().isActiveChest(enderChest);
+    public boolean b(TileEntityEnderChest tileentityenderchest) {
+        return this.owner.getEnderChest().b(tileentityenderchest);
     }
 
     @Override
     public int getMaxStackSize() {
-        return this.owner.getEnderChestInventory().getMaxStackSize();
+        return this.owner.getEnderChest().getMaxStackSize();
     }
 
     @Override
     public void setMaxStackSize(int i) {
-        this.owner.getEnderChestInventory().setMaxStackSize(i);
+        this.owner.getEnderChest().setMaxStackSize(i);
     }
 
     @Override
     public InventoryHolder getOwner() {
-        return this.owner.getEnderChestInventory().getOwner();
+        return this.owner.getEnderChest().getOwner();
     }
 
     @Override
@@ -152,69 +154,58 @@ public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpe
     }
 
     @Override
-    public void addListener(ContainerListener listener) {
-        this.owner.getEnderChestInventory().addListener(listener);
+    public void a(IInventoryListener iinventorylistener) {
+        this.owner.getEnderChest().a(iinventorylistener);
     }
 
     @Override
-    public void removeListener(ContainerListener listener) {
-        this.owner.getEnderChestInventory().removeListener(listener);
+    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.EMPTY;
+        return i >= 0 && i < this.c.size() ? this.c.get(i) : ItemStack.b;
     }
 
     @Override
-    public ItemStack removeItem(int i, int j) {
-        ItemStack itemstack = ContainerHelper.removeItem(this.items, i, j);
+    public ItemStack splitStack(int i, int j) {
+        ItemStack itemstack = ContainerUtil.a(this.c, i, j);
         if (!itemstack.isEmpty()) {
-            this.setChanged();
+            this.update();
         }
 
         return itemstack;
     }
 
     @Override
-    public ItemStack addItem(ItemStack itemstack) {
-        ItemStack localItem = itemstack.copy();
-        this.moveItemToOccupiedSlotsWithSameType(localItem);
-        if (localItem.isEmpty()) {
-            return ItemStack.EMPTY;
+    public ItemStack a(ItemStack itemstack) {
+        ItemStack itemstack1 = itemstack.cloneItemStack();
+        this.d(itemstack1);
+        if (itemstack1.isEmpty()) {
+            return ItemStack.b;
         } else {
-            this.moveItemToEmptySlots(localItem);
-            return localItem.isEmpty() ? ItemStack.EMPTY : localItem;
+            this.c(itemstack1);
+            return itemstack1.isEmpty() ? ItemStack.b : itemstack1;
         }
     }
 
-    @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());
+    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 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);
+    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;
                 }
@@ -222,91 +213,91 @@ public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpe
         }
     }
 
-    private void moveItemsBetweenStacks(ItemStack itemstack, ItemStack itemstack1) {
+    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.grow(j);
-            itemstack.shrink(j);
-            this.setChanged();
+            itemstack1.add(j);
+            itemstack.subtract(j);
+            this.update();
         }
     }
 
     @Override
-    public ItemStack removeItemNoUpdate(int i) {
-        ItemStack itemstack = this.items.get(i);
+    public ItemStack splitWithoutUpdate(int i) {
+        ItemStack itemstack = this.c.get(i);
         if (itemstack.isEmpty()) {
-            return ItemStack.EMPTY;
+            return ItemStack.b;
         } else {
-            this.items.set(i, ItemStack.EMPTY);
+            this.c.set(i, ItemStack.b);
             return itemstack;
         }
     }
 
     @Override
     public void setItem(int i, ItemStack itemstack) {
-        this.items.set(i, itemstack);
+        this.c.set(i, itemstack);
         if (!itemstack.isEmpty() && itemstack.getCount() > this.getMaxStackSize()) {
             itemstack.setCount(this.getMaxStackSize());
         }
 
-        this.setChanged();
+        this.update();
     }
 
     @Override
-    public int getContainerSize() {
-        return this.owner.getEnderChestInventory().getContainerSize();
+    public int getSize() {
+        return this.owner.getEnderChest().getSize();
     }
 
     @Override
     public boolean isEmpty() {
-        return this.items.stream().allMatch(ItemStack::isEmpty);
+        return this.c.stream().allMatch(ItemStack::isEmpty);
     }
 
     @Override
-    public void startOpen(Player player) {
+    public void startOpen(EntityHuman entityhuman) {
     }
 
     @Override
-    public void stopOpen(Player player) {
+    public void closeContainer(EntityHuman entityhuman) {
     }
 
     @Override
-    public boolean canPlaceItem(int i, ItemStack itemstack) {
+    public boolean b(int i, ItemStack itemstack) {
         return true;
     }
 
     @Override
-    public void clearContent() {
-        this.items.clear();
-        this.setChanged();
+    public void clear() {
+        this.c.clear();
+        this.update();
     }
 
     @Override
-    public void fillStackedContents(StackedContents stackedContents) {
-        for (ItemStack itemstack : this.items) {
-            stackedContents.accountStack(itemstack);
+    public void a(AutoRecipeStackManager autorecipestackmanager) {
+        for (ItemStack itemstack : this.c) {
+            autorecipestackmanager.b(itemstack);
         }
 
     }
 
     @Override
-    public List<ItemStack> removeAllItems() {
-        List<ItemStack> list = this.items.stream().filter(Predicate.not(ItemStack::isEmpty)).collect(Collectors.toList());
-        this.clearContent();
+    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 removeItemType(Item item, int i) {
+    public ItemStack a(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)) {
+        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 splitItem = localItem.split(k);
-                itemstack.grow(splitItem.getCount());
+                ItemStack itemstack2 = itemstack1.cloneAndSubtract(k);
+                itemstack.add(itemstack2.getCount());
                 if (itemstack.getCount() == i) {
                     break;
                 }
@@ -314,28 +305,34 @@ public class SpecialEnderChest extends PlayerEnderChestContainer implements ISpe
         }
 
         if (!itemstack.isEmpty()) {
-            this.setChanged();
+            this.update();
         }
 
         return itemstack;
     }
 
     @Override
-    public String toString() {
-        return this.items.stream().filter((itemStack) -> !itemStack.isEmpty()).collect(Collectors.toList()).toString();
+    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 void fromTag(ListTag listTag) {
-        for (int i = 0; i < this.getContainerSize(); ++i) {
-            this.setItem(i, ItemStack.EMPTY);
-        }
+    public String toString() {
+        return this.c.stream().filter((itemStack) -> !itemStack.isEmpty()).collect(Collectors.toList()).toString();
+    }
 
-        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));
+    @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);
             }
         }
 

internal/v1_18_R1/pom.xml

@@ -1,111 +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_18_R1</artifactId>
-  <name>OpenInvAdapter1_18_R1</name>
-
-  <properties>
-    <maven.compiler.source>17</maven.compiler.source>
-    <maven.compiler.target>17</maven.compiler.target>
-    <spigot.version>1.18-pre5-R0.1-SNAPSHOT</spigot.version>
-  </properties>
-
-  <dependencies>
-    <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot-api</artifactId>
-      <version>${spigot.version}</version>
-    </dependency>
-    <dependency>
-      <artifactId>spigot</artifactId>
-      <groupId>org.spigotmc</groupId>
-      <scope>provided</scope>
-      <version>${spigot.version}</version>
-      <classifier>remapped-mojang</classifier>
-    </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>
-        <configuration>
-          <minimizeJar>true</minimizeJar>
-        </configuration>
-      </plugin>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>net.md-5</groupId>
-        <artifactId>specialsource-maven-plugin</artifactId>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>remap</goal>
-            </goals>
-            <id>remap-obf</id>
-            <configuration>
-              <srgIn>org.spigotmc:minecraft-server:${spigot.version}:txt:maps-mojang</srgIn>
-              <reverse>true</reverse>
-              <remappedDependencies>org.spigotmc:spigot:${spigot.version}:jar:remapped-mojang</remappedDependencies>
-              <remappedArtifactAttached>true</remappedArtifactAttached>
-              <remappedClassifierName>remapped-obf</remappedClassifierName>
-            </configuration>
-          </execution>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>remap</goal>
-            </goals>
-            <id>remap-spigot</id>
-            <configuration>
-              <inputFile>${project.build.directory}/${project.artifactId}-${project.version}-remapped-obf.jar</inputFile>
-              <srgIn>org.spigotmc:minecraft-server:${spigot.version}:csrg:maps-spigot</srgIn>
-              <remappedDependencies>org.spigotmc:spigot:${spigot.version}:jar:remapped-obf</remappedDependencies>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-  </build>
-
-</project>

internal/v1_18_R1/src/main/java/com/lishid/openinv/internal/v1_18_R1/AnySilentContainer.java

@@ -1,277 +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_18_R1;
-
-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.Optional;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import net.minecraft.core.BlockPos;
-import net.minecraft.network.chat.TextComponent;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.server.level.ServerPlayerGameMode;
-import net.minecraft.world.CompoundContainer;
-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.DoubleBlockCombiner;
-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.ChestBlockEntity;
-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.Material;
-import org.bukkit.Statistic;
-import org.bukkit.block.ShulkerBox;
-import org.bukkit.craftbukkit.v1_18_R1.CraftWorld;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.InventoryView;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class AnySilentContainer implements IAnySilentContainer {
-
-    private @Nullable Field serverPlayerGameModeGameType;
-
-    public AnySilentContainer() {
-        try {
-            try {
-                // IDE warns about field not existing, but SpecialSource does not remap strings used in reflection.
-                // The warning is not suppressed as a reminder that it must manually be checked on updates.
-                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(ShulkerBox box) {
-        org.bukkit.World bukkitWorld = box.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(box.getX(), box.getY(), box.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.BlockEnderChest
-            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);
-            }, new TextComponent("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: check if chest is blocked
-            Optional<MenuProvider> menuOptional = chestBlock.combine(blockState, level, blockPos, false).apply(
-                    // Combiner is a copy of private ChestBlock.MENU_PROVIDER_COMBINER
-                    new DoubleBlockCombiner.Combiner<ChestBlockEntity, Optional<MenuProvider>>() {
-                        @Override
-                        public Optional<MenuProvider> acceptDouble(ChestBlockEntity localChest1, ChestBlockEntity localChest2) {
-                            CompoundContainer doubleChest = new CompoundContainer(localChest1, localChest2);
-                            return Optional.of(new ChestBlock.DoubleInventory(localChest1, localChest2, doubleChest));
-                        }
-
-                        @Override
-                        public Optional<MenuProvider> acceptSingle(ChestBlockEntity localChest) {
-                            return Optional.of(localChest);
-                        }
-
-                        @Override
-                        public Optional<MenuProvider> acceptNone() {
-                            return Optional.empty();
-                        }
-                    });
-
-            if (menuOptional.isEmpty()) {
-                OpenInv.getPlugin(OpenInv.class).sendSystemMessage(bukkitPlayer, "messages.error.lootNotGenerated");
-                return false;
-            }
-
-            menuProvider = menuOptional.get();
-
-            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) {
-            return;
-        }
-
-        InventoryView view = bukkitPlayer.getOpenInventory();
-        switch (view.getType()) {
-            case CHEST:
-            case ENDER_CHEST:
-            case SHULKER_BOX:
-            case BARREL:
-                break;
-            default:
-                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);
-
-        // Close container - note that this is very different from ServerPlayer#closeContainer!
-        // Triggering event must not be re-called or we'll enter an infinite loop.
-        player.doCloseContainer();
-
-        // 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();
-        }
-    }
-
-}

internal/v1_18_R1/src/main/java/com/lishid/openinv/internal/v1_18_R1/OpenPlayer.java

@@ -1,74 +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_18_R1;
-
-import java.io.File;
-import net.minecraft.Util;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.NbtIo;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.level.storage.PlayerDataStorage;
-import org.apache.logging.log4j.LogManager;
-import org.bukkit.craftbukkit.v1_18_R1.CraftServer;
-import org.bukkit.craftbukkit.v1_18_R1.entity.CraftPlayer;
-
-public class OpenPlayer extends CraftPlayer {
-
-    public OpenPlayer(CraftServer server, ServerPlayer entity) {
-        super(server, entity);
-    }
-
-    @Override
-    public void loadData() {
-        // See CraftPlayer#loadData
-        CompoundTag loaded = this.server.getHandle().playerIo.load(this.getHandle());
-        if (loaded != null) {
-            readExtraData(loaded);
-        }
-    }
-
-    @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 playerData = player.saveWithoutId(new CompoundTag());
-            setExtraData(playerData);
-
-            if (!isOnline()) {
-                // Special case: save old vehicle data
-                CompoundTag oldData = worldNBTStorage.load(player);
-
-                if (oldData != null && oldData.contains("RootVehicle", 10)) {
-                    // See net.minecraft.server.PlayerList#a(NetworkManager, EntityPlayer) and net.minecraft.server.EntityPlayer#b(NBTTagCompound)
-                    playerData.put("RootVehicle", oldData.getCompound("RootVehicle"));
-                }
-            }
-
-            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.getName().getString());
-        }
-    }
-
-}

internal/v1_18_R1/src/main/java/com/lishid/openinv/internal/v1_18_R1/SpecialEnderChest.java

@@ -1,344 +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_18_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.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_18_R1.entity.CraftHumanEntity;
-import org.bukkit.craftbukkit.v1_18_R1.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 boolean isInUse() {
-        return !this.getViewers().isEmpty();
-    }
-
-    @Override
-    public void setPlayerOffline() {
-        this.playerOnline = false;
-    }
-
-    @Override
-    public void setPlayerOnline(@NotNull final org.bukkit.entity.Player player) {
-        if (!this.playerOnline) {
-            try {
-                this.owner = PlayerDataManager.getHandle(player);
-                PlayerEnderChestContainer enderChest = owner.getEnderChestInventory();
-                for (int i = 0; i < enderChest.getContainerSize(); ++i) {
-                    enderChest.setItem(i, this.items.get(i));
-                }
-                this.items = enderChest.items;
-                enderChest.transaction.addAll(this.transaction);
-            } catch (Exception ignored) {}
-            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()).collect(Collectors.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));
-            }
-        }
-
-    }
-
-}

internal/v1_18_R1/src/main/java/com/lishid/openinv/internal/v1_18_R1/SpecialPlayerInventory.java

@@ -1,769 +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_18_R1;
-
-import com.google.common.collect.ImmutableList;
-import com.lishid.openinv.internal.ISpecialPlayerInventory;
-import java.util.Collection;
-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.Tag;
-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_18_R1.entity.CraftHumanEntity;
-import org.bukkit.craftbukkit.v1_18_R1.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) {
-            Player entityPlayer = PlayerDataManager.getHandle(player);
-            entityPlayer.getInventory().transaction.addAll(this.transaction);
-            this.player = entityPlayer;
-            for (int i = 0; i < getContainerSize(); ++i) {
-                this.player.getInventory().setItem(i, getRawItem(i));
-            }
-            this.player.getInventory().selected = this.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);
-            this.playerOnline = true;
-        }
-    }
-
-    @Override
-    public @NotNull CraftInventory getBukkitInventory() {
-        return this.inventory;
-    }
-
-    @Override
-    public void setPlayerOffline() {
-        this.playerOnline = false;
-    }
-
-    @Override
-    public boolean isInUse() {
-        return !this.getViewers().isEmpty();
-    }
-
-    @Override
-    public @NotNull HumanEntity getPlayer() {
-        return this.player.getBukkitEntity();
-    }
-
-    private @NotNull ItemStack getRawItem(int i) {
-        return super.getItem(i);
-    }
-
-    private void setRawItem(int i, @NotNull ItemStack itemStack) {
-        super.setItem(i, itemStack);
-    }
-
-    private static 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.isFire() || !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(Tag<Item> tag) {
-        return contains(itemStack -> !itemStack.isEmpty() && itemStack.is(tag));
-    }
-
-    @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);
-    }
-
-}

plugin/pom.xml

@@ -37,12 +37,8 @@
       <groupId>org.jetbrains</groupId>
     </dependency>
     <dependency>
-      <artifactId>paper-api</artifactId>
-      <groupId>io.papermc.paper</groupId>
-    </dependency>
-    <dependency>
-      <artifactId>planarwrappers</artifactId>
-      <groupId>com.github.jikoo</groupId>
+      <artifactId>spigot-api</artifactId>
+      <groupId>org.spigotmc</groupId>
     </dependency>
   </dependencies>
 

plugin/src/main/java/com/lishid/openinv/OpenInv.java

@@ -20,7 +20,9 @@ import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
 import com.lishid.openinv.commands.ContainerSettingCommand;
 import com.lishid.openinv.commands.OpenInvCommand;
-import com.lishid.openinv.commands.SearchCommand;
+import com.lishid.openinv.commands.SearchContainerCommand;
+import com.lishid.openinv.commands.SearchEnchantCommand;
+import com.lishid.openinv.commands.SearchInvCommand;
 import com.lishid.openinv.internal.IAnySilentContainer;
 import com.lishid.openinv.internal.ISpecialEnderChest;
 import com.lishid.openinv.internal.ISpecialInventory;
@@ -293,10 +295,6 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
     }
 
     public void sendSystemMessage(@NotNull Player player, @NotNull String key) {
-        this.sendSystemMessage(player, key, new String[0]);
-    }
-
-    public void sendSystemMessage(@NotNull Player player, @NotNull String key, String... replacements) {
         String message = this.languageManager.getValue(key, getLocale(player));
 
         if (message == null) {
@@ -332,14 +330,6 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
         }
     }
 
-    public int getSearchPollsPerTick() {
-        return this.getConfig().getInt("settings.search.polls-per-tick", 5);
-    }
-
-    public int getSearchResultsMax() {
-        return this.getConfig().getInt("settings.search.max-results", 40);
-    }
-
     @Override
     public void onDisable() {
 
@@ -377,7 +367,9 @@ public class OpenInv extends JavaPlugin implements IOpenInv {
 
             // Register commands to their executors
             this.setCommandExecutor(new OpenInvCommand(this), "openinv", "openender");
-            this.setCommandExecutor(new SearchCommand(this), "search");
+            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 {

plugin/src/main/java/com/lishid/openinv/commands/SearchCommand.java

@@ -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.commands;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.commands.search.ChunkSearchOption;
-import com.lishid.openinv.commands.search.CompletableOption;
-import com.lishid.openinv.commands.search.ItemAmountOption;
-import com.lishid.openinv.commands.search.ItemEnchantOption;
-import com.lishid.openinv.commands.search.ItemTypeOption;
-import com.lishid.openinv.commands.search.PlayerSearchOption;
-import com.lishid.openinv.commands.search.PseudoOption;
-import com.lishid.openinv.search.Search;
-import com.lishid.openinv.search.bucket.SearchBucket;
-import com.lishid.openinv.search.match.ItemMatcher;
-import com.lishid.openinv.search.match.MatchableItem;
-import com.lishid.openinv.search.match.MatchableMeta;
-import com.lishid.openinv.util.PseudoJson;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabExecutor;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class SearchCommand implements TabExecutor {
-
-    private final OpenInv plugin;
-    private final Collection<String> activeSearches = Collections.newSetFromMap(new ConcurrentHashMap<>());
-
-    private final Collection<CompletableOption<SearchBucket>> completableSearchBuckets = new HashSet<>();
-    private final Collection<CompletableOption<MatchableItem>> completableMatchOptions = new HashSet<>();
-    private final Collection<CompletableOption<MatchableMeta>> completableMatchMetaOptions = new HashSet<>();
-
-    public SearchCommand(OpenInv plugin) {
-        this.plugin = plugin;
-
-        this.completableSearchBuckets.add(new ChunkSearchOption());
-        this.completableSearchBuckets.add(new PlayerSearchOption(plugin));
-        this.completableMatchOptions.add(new ItemAmountOption());
-        this.completableMatchOptions.add(new ItemTypeOption());
-        this.completableMatchMetaOptions.add(new ItemEnchantOption());
-    }
-
-    @Override
-    public boolean onCommand(
-            @NotNull CommandSender sender,
-            @NotNull Command command,
-            @NotNull String label,
-            @NotNull String[] args) {
-
-        if (args.length < 2) {
-            return false;
-        }
-
-        String id = sender instanceof Player ? plugin.getPlayerID((Player) sender) : "CONSOLE";
-
-        if (activeSearches.contains(id)) {
-            plugin.sendMessage(sender, "messages.error.search.activeSearch");
-            return true;
-        }
-
-        Collection<PseudoJson> arguments = new HashSet<>();
-        for (String arg : args) {
-            arg = arg.toLowerCase(Locale.ROOT);
-            try {
-                arguments.add(PseudoJson.fromString(arg));
-            } catch (IllegalArgumentException e) {
-                plugin.sendMessage(sender, "messages.error.search.invalidSchema", "%value%", arg);
-                return true;
-            }
-        }
-
-        Collection<SearchBucket> searchBuckets = getSearchBuckets(sender, arguments);
-
-        if (searchBuckets.isEmpty()) {
-            plugin.sendMessage(sender, "messages.error.search.invalidInventory");
-            return true;
-        }
-
-        ItemMatcher matcher = getMatcher(sender, arguments);
-
-        if (matcher == null) {
-            plugin.sendMessage(sender, "messages.error.search.invalidMatcher");
-            return true;
-        }
-
-        activeSearches.add(id);
-
-        new Search(matcher, searchBuckets, () -> activeSearches.remove(id)).schedule(sender, plugin);
-
-        return true;
-    }
-
-    private @Nullable ItemMatcher getMatcher(@NotNull CommandSender sender, @NotNull Collection<PseudoJson> args) {
-        List<PseudoOption<MatchableItem>> matchItemOptions = new ArrayList<>();
-        List<PseudoOption<MatchableMeta>> matchMetaOptions = new ArrayList<>();
-
-
-        for (PseudoJson arg : args) {
-            addMatchOptions(completableMatchOptions, matchItemOptions, sender, arg);
-            addMatchOptions(completableMatchMetaOptions, matchMetaOptions, sender, arg);
-        }
-
-        // Must have a match option. Null entries indicate a parsing error.
-        if (matchItemOptions.isEmpty()
-                || matchItemOptions.stream().anyMatch(Objects::isNull)
-                || matchMetaOptions.stream().anyMatch(Objects::isNull)) {
-            return null;
-        }
-
-        return new ItemMatcher(
-                matchItemOptions.stream().map(PseudoOption::option).toList(),
-                matchMetaOptions.stream().map(PseudoOption::option).toList());
-    }
-
-    private <T> void addMatchOptions(
-            @NotNull Collection<CompletableOption<T>> completableOptions,
-            @NotNull Collection<PseudoOption<T>> options,
-            @NotNull CommandSender sender,
-            @NotNull PseudoJson arg) {
-        for (CompletableOption<T> option : completableOptions) {
-            if (option.matches(sender, arg)) {
-                PseudoOption<T> parsed = option.parse(sender, arg);
-                if (parsed == null) {
-                    options.add(null);
-                    continue;
-                }
-
-                if (option.isUnique()) {
-                    String uniqueId = option.getName();
-
-                    // Match existing options.
-                    List<PseudoOption<T>> matches = options.stream()
-                            .filter(Objects::nonNull)
-                            .filter(bucket -> bucket.pseudoJson().getIdentifier().equals(uniqueId))
-                            .collect(Collectors.toList());
-
-                    // Remove all existing options.
-                    options.removeAll(matches);
-
-                    // Merge with existing options.
-                    for (PseudoOption<T> match : matches) {
-                        PseudoOption<T> newParsed = option.merge(sender, match, parsed);
-                        if (newParsed != null) {
-                            parsed = newParsed;
-                        }
-                    }
-                }
-                options.add(parsed);
-            }
-        }
-    }
-
-    private Collection<SearchBucket> getSearchBuckets(
-            @NotNull CommandSender sender,
-            @NotNull Collection<PseudoJson> args) {
-        List<PseudoOption<SearchBucket>> buckets = new ArrayList<>();
-
-        for (PseudoJson arg : args) {
-            addMatchOptions(completableSearchBuckets, buckets, sender, arg);
-        }
-
-        return buckets.stream().map(PseudoOption::option).collect(Collectors.toList());
-    }
-
-    @Override
-    public @Nullable List<String> onTabComplete(
-            @NotNull CommandSender sender,
-            @NotNull Command command,
-            @NotNull String label,
-            @NotNull String[] args) {
-
-        List<PseudoJson> arguments = new ArrayList<>();
-
-        for (int i = 0; i < args.length; i++) {
-            String arg = args[i].toLowerCase(Locale.ROOT);
-            try {
-                arguments.add(PseudoJson.fromString(arg));
-            } catch (IllegalArgumentException e) {
-                if (i == args.length - 1) {
-                    // If last argument cannot be parsed, do not complete.
-                    return List.of();
-                }
-                // Otherwise, ignore formatting issues during tab completion.
-            }
-
-        }
-
-        // Ensure an argument exists.
-        if (arguments.isEmpty()) {
-            arguments.add(new PseudoJson(""));
-        }
-
-        // Remove last indexed argument, it is being completed.
-        PseudoJson last = arguments.remove(arguments.size() - 1);
-
-        // Due to generics, can't just use generic list of options to start with.
-        Collection<PseudoOption<SearchBucket>> buckets = new HashSet<>();
-        Collection<PseudoOption<MatchableItem>> items = new HashSet<>();
-        Collection<PseudoOption<MatchableMeta>> metas = new HashSet<>();
-        for (PseudoJson arg : arguments) {
-            addMatchOptions(completableSearchBuckets, buckets, sender, arg);
-            addMatchOptions(completableMatchOptions, items, sender, arg);
-            addMatchOptions(completableMatchMetaOptions, metas, sender, arg);
-        }
-        Collection<PseudoOption<?>> options = new HashSet<>();
-        options.addAll(buckets);
-        options.addAll(items);
-        options.addAll(metas);
-
-        // Suggest all completable options' completions.
-        return Stream.concat(completableSearchBuckets.stream(),
-                Stream.concat(completableMatchOptions.stream(),
-                        completableMatchMetaOptions.stream()))
-                // Don't suggest unique options that are already present.
-                .filter(option ->
-                        option.isUnique() && options.stream().anyMatch(pseudoOption ->
-                                pseudoOption.pseudoJson().getIdentifier().equals(option.getName())))
-                .flatMap(option -> option.suggestOptions(sender, last).stream())
-                .distinct()
-                .toList();
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/commands/SearchContainerCommand.java

@@ -0,0 +1,129 @@
+/*
+ * 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.commands;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.util.TabCompleter;
+import java.util.Collections;
+import java.util.List;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.BlockState;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Command for searching containers in a radius of chunks.
+ */
+public class SearchContainerCommand implements TabExecutor {
+
+    private final OpenInv plugin;
+
+    public SearchContainerCommand(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!(sender instanceof Player)) {
+            plugin.sendMessage(sender, "messages.error.consoleUnsupported");
+            return true;
+        }
+
+        if (args.length < 1) {
+            // Must supply material
+            return false;
+        }
+
+        Material material = Material.getMaterial(args[0].toUpperCase());
+
+        if (material == null) {
+            plugin.sendMessage(sender, "messages.error.invalidMaterial", "%target%", args[0]);
+            return false;
+        }
+
+        int radius = 5;
+
+        if (args.length > 1) {
+            try {
+                radius = Integer.parseInt(args[1]);
+            } catch (NumberFormatException e) {
+                // Invalid radius supplied
+                return false;
+            }
+        }
+
+        Player senderPlayer = (Player) sender;
+        World world = senderPlayer.getWorld();
+        Chunk centerChunk = senderPlayer.getLocation().getChunk();
+        StringBuilder locations = new StringBuilder();
+
+        for (int dX = -radius; dX <= radius; ++dX) {
+            for (int dZ = -radius; dZ <= radius; ++dZ) {
+                if (!world.loadChunk(centerChunk.getX() + dX, centerChunk.getZ() + dZ, false)) {
+                    continue;
+                }
+                Chunk chunk = world.getChunkAt(centerChunk.getX() + dX, centerChunk.getZ() + dZ);
+                for (BlockState tileEntity : chunk.getTileEntities()) {
+                    if (!(tileEntity instanceof InventoryHolder)) {
+                        continue;
+                    }
+                    InventoryHolder holder = (InventoryHolder) tileEntity;
+                    if (!holder.getInventory().contains(material)) {
+                        continue;
+                    }
+                    locations.append(holder.getInventory().getType().name().toLowerCase()).append(" (")
+                            .append(tileEntity.getX()).append(',').append(tileEntity.getY()).append(',')
+                            .append(tileEntity.getZ()).append("), ");
+                }
+            }
+        }
+
+        // Matches found, delete trailing comma and space
+        if (locations.length() > 0) {
+            locations.delete(locations.length() - 2, locations.length());
+        } else {
+            plugin.sendMessage(sender, "messages.info.container.noMatches",
+                    "%target%", material.name());
+            return true;
+        }
+
+        plugin.sendMessage(sender, "messages.info.container.matches",
+                "%target%", material.name(), "%detail%", locations.toString());
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+        if (args.length < 1 || args.length > 2 || !command.testPermissionSilent(sender)) {
+            return Collections.emptyList();
+        }
+
+        String argument = args[args.length - 1];
+        if (args.length == 1) {
+            return TabCompleter.completeEnum(argument, Material.class);
+        } else {
+            return TabCompleter.completeInteger(argument);
+        }
+    }
+
+}

plugin/src/main/java/com/lishid/openinv/commands/SearchEnchantCommand.java

@@ -0,0 +1,169 @@
+/*
+ * 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.commands;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.util.TabCompleter;
+import java.util.Collections;
+import java.util.List;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Command adding the ability to search online players' inventories for enchantments of a specific
+ * type at or above the level specified.
+ *
+ * @author Jikoo
+ */
+public class SearchEnchantCommand implements TabExecutor {
+
+    private final OpenInv plugin;
+
+    public SearchEnchantCommand(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (args.length == 0) {
+            return false;
+        }
+
+        Enchantment enchant = null;
+        int level = 0;
+
+        for (String argument : args) {
+            try {
+                level = Integer.parseInt(argument);
+                continue;
+            } catch (NumberFormatException ignored) {}
+
+            argument = argument.toLowerCase();
+            int colon = argument.indexOf(':');
+            NamespacedKey key;
+            try {
+                if (colon > -1 && colon < argument.length() - 1) {
+                    key = new NamespacedKey(argument.substring(0, colon), argument.substring(colon + 1));
+                } else {
+                    key = NamespacedKey.minecraft(argument);
+                }
+            } catch (IllegalArgumentException ignored) {
+                continue;
+            }
+
+            Enchantment localEnchant = Enchantment.getByKey(key);
+            if (localEnchant != null) {
+                enchant = localEnchant;
+            }
+        }
+
+        // Arguments not set correctly
+        if (level == 0 && enchant == null) {
+            return false;
+        }
+
+        StringBuilder players = new StringBuilder();
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            boolean flagInventory = containsEnchantment(player.getInventory(), enchant, level);
+            boolean flagEnder = containsEnchantment(player.getEnderChest(), enchant, level);
+
+            // No matches, continue
+            if (!flagInventory && !flagEnder) {
+                continue;
+            }
+
+            // Matches, append details
+            players.append(player.getName()).append(" (");
+            if (flagInventory) {
+                players.append("inv");
+            }
+            if (flagEnder) {
+                if (flagInventory) {
+                    players.append(',');
+                }
+                players.append("ender");
+            }
+            players.append("), ");
+        }
+
+        if (players.length() > 0) {
+            // 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);
+            return true;
+        }
+
+        plugin.sendMessage(sender, "messages.info.player.matches",
+                "%target%", (enchant != null ? enchant.getKey().toString() : "") + " >= " + level,
+                "%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;
+            }
+            if (enchant != null) {
+                if (item.containsEnchantment(enchant) && item.getEnchantmentLevel(enchant) >= minLevel) {
+                    return true;
+                }
+            } else {
+                if (!item.hasItemMeta()) {
+                    continue;
+                }
+                ItemMeta meta = item.getItemMeta();
+                if (meta == null || !meta.hasEnchants()) {
+                    continue;
+                }
+                for (int enchLevel : meta.getEnchants().values()) {
+                    if (enchLevel >= minLevel) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!command.testPermissionSilent(sender) || args.length < 1 || args.length > 2) {
+            return Collections.emptyList();
+        }
+
+        if (args.length == 1) {
+            return TabCompleter.completeObject(args[0], enchantment -> enchantment.getKey().toString(), Enchantment.values());
+        } else {
+            return TabCompleter.completeInteger(args[1]);
+        }
+    }
+
+}

plugin/src/main/java/com/lishid/openinv/commands/SearchInvCommand.java

@@ -0,0 +1,101 @@
+/*
+ * 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.commands;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.util.TabCompleter;
+import java.util.Collections;
+import java.util.List;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.jetbrains.annotations.NotNull;
+
+public class SearchInvCommand implements TabExecutor {
+
+    private final OpenInv plugin;
+
+    public SearchInvCommand(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+
+        Material material = null;
+
+        if (args.length >= 1) {
+            material = Material.getMaterial(args[0].toUpperCase());
+        }
+
+        if (material == null) {
+            plugin.sendMessage(sender, "messages.error.invalidMaterial", "%target%", args.length > 0 ? args[0] : "null");
+            return false;
+        }
+
+        int count = 1;
+
+        if (args.length >= 2) {
+            try {
+                count = Integer.parseInt(args[1]);
+            } catch (NumberFormatException ex) {
+                plugin.sendMessage(sender, "messages.error.invalidNumber", "%target%", args[1]);
+                return false;
+            }
+        }
+
+        StringBuilder players = new StringBuilder();
+        boolean searchInv = command.getName().equals("searchinv");
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            Inventory inventory = searchInv ? player.getInventory() : player.getEnderChest();
+            if (inventory.contains(material, count)) {
+                players.append(player.getName()).append(", ");
+            }
+        }
+
+        // Matches found, delete trailing comma and space
+        if (players.length() > 0) {
+            players.delete(players.length() - 2, players.length());
+        } else {
+            plugin.sendMessage(sender, "messages.info.player.noMatches",
+                    "%target%", material.name());
+            return true;
+        }
+
+        plugin.sendMessage(sender, "messages.info.player.matches",
+                "%target%", material.name(), "%detail%", players.toString());
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (args.length < 1 || args.length > 2 || !command.testPermissionSilent(sender)) {
+            return Collections.emptyList();
+        }
+
+        String argument = args[args.length - 1];
+        if (args.length == 1) {
+            return TabCompleter.completeEnum(argument, Material.class);
+        } else {
+            return TabCompleter.completeInteger(argument);
+        }
+    }
+
+}

plugin/src/main/java/com/lishid/openinv/commands/search/ChunkSearchOption.java

@@ -1,125 +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.commands.search;
-
-import com.lishid.openinv.search.bucket.ChunkBucket;
-import com.lishid.openinv.search.bucket.SearchBucket;
-import com.lishid.openinv.util.Permissions;
-import com.lishid.openinv.util.PseudoJson;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Set;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class ChunkSearchOption implements CompletableOption<SearchBucket> {
-
-    @Override
-    public @NotNull String getName() {
-        return "chunk";
-    }
-
-    @Override
-    public boolean matches(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        return CompletableOption.super.matches(sender, pseudoJson)
-                && Permissions.SEARCH_CHUNKS_LOADED.hasPermission(sender);
-    }
-
-    @Override
-    public @Nullable PseudoOption<SearchBucket> parse(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        World world = null;
-        Integer chunkX = null;
-        Integer chunkZ = null;
-        int chunkRadius = 5;
-        boolean chunkLoad = false;
-        Map<String, String> mappings = pseudoJson.getMappings();
-
-        if (!(sender instanceof Player senderPlayer)) {
-            if (mappings.size() < 3) {
-                // Console must specify world, x center, z center.
-                return null;
-            }
-        } else {
-            world = senderPlayer.getWorld();
-            Chunk senderChunk = senderPlayer.getLocation().getChunk();
-            chunkX = senderChunk.getX();
-            chunkZ = senderChunk.getZ();
-        }
-
-        for (Map.Entry<String, String> entry : mappings.entrySet()) {
-            String key = entry.getKey();
-            String value = entry.getValue();
-
-            if (key.indexOf('w') >= 0) {
-                world = null;
-                // Name should always be lower case by this point. Ignore case when selecting world.
-                for (World loaded : Bukkit.getWorlds()) {
-                    if (loaded.getName().equalsIgnoreCase(value)) {
-                        world = loaded;
-                        break;
-                    }
-                }
-            } else if (key.indexOf('x') >= 0) {
-                try {
-                    chunkX = Integer.parseInt(value);
-                } catch (NumberFormatException e) {
-                    chunkX = null;
-                }
-            } else if (key.indexOf('z') >= 0) {
-                try {
-                    chunkZ = Integer.parseInt(value);
-                } catch (NumberFormatException e) {
-                    chunkZ = null;
-                }
-            } else if (key.indexOf('r') >= 0) {
-                // R is for radius. Needs to be checked later so that "world" doesn't result in a false positive.
-                try {
-                    chunkRadius = Integer.parseInt(value);
-                } catch (NumberFormatException e) {
-                    // Fall through to default radius.
-                }
-            } else if (key.indexOf('l') >= 0) {
-                // L is for loaded. Needs to be checked later so that "world" doesn't result in a false positive.
-                chunkLoad = Permissions.SEARCH_CHUNKS_UNLOADED.hasPermission(sender) && Boolean.parseBoolean(value);
-            }
-        }
-
-        if (world == null || chunkX == null || chunkZ == null || chunkRadius < 0) {
-            // Invalid data provided.
-            return null;
-        }
-
-        return new PseudoOption<>(pseudoJson, new ChunkBucket(world, chunkX, chunkZ, chunkRadius, chunkLoad));
-    }
-
-    @Override
-    public @NotNull Collection<String> suggestOptions(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        // TODO
-        return Set.of();
-    }
-
-    @Override
-    public boolean isUnique() {
-        return false;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/commands/search/CompletableOption.java

@@ -1,110 +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.commands.search;
-
-import com.lishid.openinv.util.PseudoJson;
-import java.util.Collection;
-import java.util.Locale;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * Interface defining behavior for an option.
- *
- * @param <T> the type of option represented
- */
-public interface CompletableOption<T> {
-
-    /**
-     * Get unique identifier representing the option.
-     *
-     * @return the unique identifier
-     */
-    @NotNull String getName();
-
-    /**
-     * Check if the <code>CompletableOption</code> matches the given <code>PseudoJson</code>.
-     *
-     * @param sender the individual using the option
-     * @param pseudoJson the pseudo-JSON element
-     * @return true if the CompletableOption matches
-     */
-    default boolean matches(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        return pseudoJson.getIdentifier().toLowerCase(Locale.ROOT).startsWith(getName());
-    }
-
-    /**
-     * Parse the option represented from the given <code>PseudoJson</code>.
-     *
-     * @param sender the individual using the option
-     * @param pseudoJson the pseudo-JSON element
-     * @return the parsed options
-     */
-    @Nullable PseudoOption<T> parse(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson);
-
-    /**
-     * Form a collection of viable permutations to suggest for the given <code>PseudoJson</code>.
-     *
-     * @param sender the individual to suggest options for
-     * @param pseudoJson the parsed pseudo-JSON
-     * @return the suggested permutations
-     */
-    @NotNull Collection<String> suggestOptions(
-            @NotNull CommandSender sender,
-            @NotNull PseudoJson pseudoJson);
-
-    /**
-     * Get whether or not multiple different copies of this <code>CompletableOption</code> are allowed.
-     *
-     * @return true if only a single instance is allowed
-     */
-    boolean isUnique();
-
-    /**
-     * Merge similar elements. Used to enforce {@link #isUnique()} despite multiples being provided.
-     *
-     * @param sender the individual using the options
-     * @param first the first parsed option
-     * @param second the second parsed option
-     * @return a single element containing a best-effort merge of both
-     */
-    default @Nullable PseudoOption<T> merge(
-            @NotNull CommandSender sender,
-            @NotNull PseudoOption<?> first,
-            @NotNull PseudoOption<?> second) {
-        PseudoJson merge = new PseudoJson(first.pseudoJson().getIdentifier());
-
-        // Use mappings of first for our base.
-        first.pseudoJson().getMappings().forEach(merge::put);
-        // Overwrite with second.
-        second.pseudoJson().getMappings().forEach(merge::put);
-
-        // Parse merged options.
-        PseudoOption<T> parsed = parse(sender, merge);
-
-        if (parsed != null) {
-            return parsed;
-        }
-
-        // On parsing failure, try second instead.
-        merge = new PseudoJson(second.pseudoJson().getIdentifier(), merge.getMappings());
-
-        return parse(sender, merge);
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/commands/search/ItemAmountOption.java

@@ -1,84 +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.commands.search;
-
-import com.lishid.openinv.search.match.ItemMatchables;
-import com.lishid.openinv.search.match.MatchableItem;
-import com.lishid.openinv.util.PseudoJson;
-import com.lishid.openinv.util.TabCompleter;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import org.bukkit.command.CommandSender;
-import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class ItemAmountOption implements CompletableOption<MatchableItem> {
-
-    @Override
-    public @NotNull String getName() {
-        return "amount";
-    }
-
-    @Override
-    public @Nullable PseudoOption<MatchableItem> parse(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        String minAmountString = pseudoJson.getMappings().entrySet().stream().findFirst().map(Map.Entry::getValue).orElse(null);
-        if (minAmountString == null) {
-            // Amount not correctly specified. Warn about spec.
-            return null;
-        }
-        int minAmount;
-        try {
-            minAmount = Integer.parseInt(minAmountString);
-        } catch (NumberFormatException e) {
-            // Amount can't be parsed. Warn about spec.
-            return null;
-        }
-
-        return new PseudoOption<>(pseudoJson, ItemMatchables.hasAmount(minAmount));
-    }
-
-    @Override
-    public @NotNull Collection<String> suggestOptions(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        // TODO combine with type
-        if (!pseudoJson.getIdentifier().equals(getName())) {
-            // Suggest name while unformed.
-            if (StringUtil.startsWithIgnoreCase(getName(), pseudoJson.getIdentifier())) {
-                return Set.of(getName() + ":");
-            }
-            // If name is not a valid suggestion, suggest nothing.
-            return Set.of();
-        }
-
-        String minAmountString = pseudoJson.getMappings().entrySet().stream().findFirst().map(Map.Entry::getValue).orElse("");
-
-        // Find and suggest name in full pseudojson.
-        return TabCompleter.completeInteger(minAmountString).stream().map(match -> {
-            PseudoJson amount = new PseudoJson(getName());
-            amount.put(getName(), match);
-            return amount;
-        }).map(PseudoJson::asString).collect(Collectors.toSet());
-    }
-
-    @Override
-    public boolean isUnique() {
-        return true;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/commands/search/ItemEnchantOption.java

@@ -1,137 +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.commands.search;
-
-import com.github.jikoo.planarwrappers.util.StringConverters;
-import com.lishid.openinv.search.match.ItemMatchables;
-import com.lishid.openinv.search.match.MatchableMeta;
-import com.lishid.openinv.util.PseudoJson;
-import com.lishid.openinv.util.TabCompleter;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import org.bukkit.command.CommandSender;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class ItemEnchantOption implements CompletableOption<MatchableMeta> {
-
-    @Override
-    public @NotNull String getName() {
-        return "enchant";
-    }
-
-    @Override
-    public @Nullable PseudoOption<MatchableMeta> parse(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        Enchantment enchantment = null;
-        Integer enchantLevel = null;
-        for (Map.Entry<String, String> entry : pseudoJson.getMappings().entrySet()) {
-            if (entry.getValue().isBlank()) {
-                continue;
-            }
-            if (entry.getKey().indexOf('l') >= 0) {
-                try {
-                    enchantLevel = Integer.parseInt(entry.getValue());
-                } catch (NumberFormatException e) {
-                    // Level can't be parsed. Warn about spec.
-                    return null;
-                }
-            }
-            if (entry.getKey().indexOf('t') >= 0) {
-                enchantment = StringConverters.toEnchant(entry.getValue());
-                if (enchantment == null) {
-                    // Enchantment is specified but can't be parsed. Warn about spec.
-                    return null;
-                }
-            }
-        }
-
-        return new PseudoOption<>(pseudoJson, ItemMatchables.hasEnchant(enchantment, enchantLevel));
-    }
-
-    @Override
-    public @NotNull Collection<String> suggestOptions(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        if (!pseudoJson.getIdentifier().equals(getName())) {
-            if (!StringUtil.startsWithIgnoreCase(getName(), pseudoJson.getIdentifier())) {
-                // If enchant is not a valid suggestion, suggest nothing.
-                return Set.of();
-            }
-
-            // Suggest all options while unformed.
-            Set<String> set = new HashSet<>();
-            PseudoJson enchant = new PseudoJson(getName());
-            set.add(enchant.asString());
-            enchant.put("type", "");
-            set.add(enchant.asString());
-            enchant.put("level", "");
-            set.add(enchant.asString());
-            enchant.remove("type");
-            set.add(enchant.asString());
-            return set;
-        }
-
-        Collection<String> enchantments = null;
-        Integer enchantLevel = null;
-        for (Map.Entry<String, String> entry : pseudoJson.getMappings().entrySet()) {
-            if (entry.getValue().isBlank()) {
-                continue;
-            }
-            if (entry.getKey().indexOf('l') >= 0) {
-                try {
-                    enchantLevel = Integer.parseInt(entry.getValue());
-                } catch (NumberFormatException e) {
-                    // Level is present but cannot be parsed. Default 0.
-                    enchantLevel = 0;
-                }
-            }
-            if (entry.getKey().indexOf('t') >= 0) {
-                Enchantment enchant = StringConverters.toEnchant(entry.getValue());
-                if (enchant == null) {
-                    // Enchantment is specified but can't be parsed, tab complete.
-                    enchantments = TabCompleter.completeKeyed(entry.getValue(), Enchantment.values());
-                } else {
-                    enchantments = Set.of(entry.getValue());
-                }
-            }
-        }
-
-        PseudoJson enchant = new PseudoJson(getName());
-        if (enchantLevel != null) {
-            enchant.put("level", String.valueOf(enchantLevel));
-        }
-
-        if (enchantments == null) {
-            return Set.of(enchant.asString());
-        }
-
-        return enchantments.stream().map(enchantment -> {
-            // Reuse is fine, single-threaded.
-            enchant.put("type", enchantment);
-            return enchant;
-        }).map(PseudoJson::asString).collect(Collectors.toSet());
-    }
-
-    @Override
-    public boolean isUnique() {
-        return false;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/commands/search/ItemTypeOption.java

@@ -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.commands.search;
-
-import com.github.jikoo.planarwrappers.util.StringConverters;
-import com.lishid.openinv.search.match.ItemMatchables;
-import com.lishid.openinv.search.match.MatchableItem;
-import com.lishid.openinv.util.PseudoJson;
-import com.lishid.openinv.util.TabCompleter;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import org.bukkit.Material;
-import org.bukkit.command.CommandSender;
-import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class ItemTypeOption implements CompletableOption<MatchableItem> {
-
-    @Override
-    public @NotNull String getName() {
-        return "type";
-    }
-
-    @Override
-    public @Nullable PseudoOption<MatchableItem> parse(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        String typeName = pseudoJson.getMappings().entrySet().stream().findFirst().map(Map.Entry::getValue).orElse(null);
-        Material material = StringConverters.toMaterial(typeName);
-        if (material == null) {
-            // Invalid material, warn about matcher spec.
-            return null;
-        }
-        return new PseudoOption<>(pseudoJson, ItemMatchables.isType(material));
-    }
-
-    @Override
-    public @NotNull Collection<String> suggestOptions(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        if (!pseudoJson.getIdentifier().equals(getName())) {
-            // Suggest name while unformed.
-            if (StringUtil.startsWithIgnoreCase(getName(), pseudoJson.getIdentifier())) {
-                return Set.of(getName() + ":");
-            }
-            // If name is not a valid suggestion, suggest nothing.
-            return Set.of();
-        }
-
-        String typeName = pseudoJson.getMappings().entrySet().stream().findFirst().map(Map.Entry::getValue).orElse("");
-
-        // Find and suggest matching types in full pseudojson.
-        return TabCompleter.completeMaterial(typeName).stream().map(match -> {
-            PseudoJson type = new PseudoJson(getName());
-            type.put(getName(), match);
-            return type;
-        }).map(PseudoJson::asString).collect(Collectors.toSet());
-    }
-
-    @Override
-    public boolean isUnique() {
-        return true;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/commands/search/PlayerSearchOption.java

@@ -1,75 +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.commands.search;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.search.bucket.PlayerBucket;
-import com.lishid.openinv.search.bucket.SearchBucket;
-import com.lishid.openinv.util.Permissions;
-import com.lishid.openinv.util.PseudoJson;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class PlayerSearchOption implements CompletableOption<SearchBucket> {
-
-    private final OpenInv plugin;
-
-    public PlayerSearchOption(OpenInv plugin) {
-        this.plugin = plugin;
-    }
-
-    @Override
-    public @NotNull String getName() {
-        return "player";
-    }
-
-    @Override
-    public boolean matches(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        return CompletableOption.super.matches(sender, pseudoJson)
-                && Permissions.SEARCH_PLAYERS_ONLINE.hasPermission(sender);
-    }
-
-    @Override
-    public @Nullable PseudoOption<SearchBucket> parse(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        Optional<Boolean> optional = pseudoJson.getMappings().entrySet().stream()
-                .filter(entry -> entry.getKey().contains("offline"))
-                .findFirst()
-                .map(Map.Entry::getValue)
-                .map(Boolean::parseBoolean);
-
-        return new PseudoOption<>(
-                pseudoJson, new PlayerBucket(plugin,
-                !(optional.orElse(false) && Permissions.SEARCH_PLAYERS_OFFLINE.hasPermission(sender))));
-    }
-
-    @Override
-    public @NotNull Collection<String> suggestOptions(@NotNull CommandSender sender, @NotNull PseudoJson pseudoJson) {
-        // TODO
-        return Set.of();
-    }
-
-    @Override
-    public boolean isUnique() {
-        return true;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/commands/search/PseudoOption.java

@@ -1,27 +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.commands.search;
-
-import com.lishid.openinv.util.PseudoJson;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * Data holder for completable options.
- *
- * @param <T> the type of data
- */
-public record PseudoOption<T>(@NotNull PseudoJson pseudoJson, @NotNull T option) {}

plugin/src/main/java/com/lishid/openinv/search/Search.java

@@ -1,210 +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.search;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.search.bucket.SearchBucket;
-import com.lishid.openinv.search.match.ItemMatcher;
-import com.lishid.openinv.search.match.MatchResult;
-import com.lishid.openinv.search.match.Matchable;
-import com.lishid.openinv.util.MessagePart;
-import java.text.DecimalFormat;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.stream.Collectors;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.TextComponent;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitRunnable;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * A search function.
- */
-public class Search {
-
-    public static final BaseComponent SEPARATOR = new TextComponent(", ");
-
-    private final Set<MessagePart> matches = new HashSet<>();
-    private final ItemMatcher matcher;
-    private final double totalMatchables;
-    private final Iterator<SearchBucket> bucketIterator;
-    private final Runnable callback;
-    private SearchBucket current = null;
-    private int polls = 0;
-
-    public Search(
-            @NotNull ItemMatcher matcher,
-            @NotNull Collection<@NotNull SearchBucket> buckets,
-            @Nullable Runnable callback) {
-        // Just in case, copy contents to new set.
-        Set<SearchBucket> bucketSet = new HashSet<>(buckets);
-        this.matcher = matcher;
-        this.totalMatchables = bucketSet.stream().mapToInt(SearchBucket::size).sum();
-        this.bucketIterator = bucketSet.iterator();
-        this.callback = callback;
-    }
-
-    private boolean isComplete(OpenInv plugin) {
-        if (matches.size() >= plugin.getSearchResultsMax()) {
-            return true;
-        }
-        if (current != null && current.hasNext()) {
-            return false;
-        }
-        while (bucketIterator.hasNext()) {
-            current = bucketIterator.next();
-            if (current.hasNext()) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Search the configured amount of Matchables.
-     *
-     * <p>Matchables are assembled asynchronously, then
-     *
-     * @param plugin the OpenInv instance
-     */
-    private void poll(OpenInv plugin) {
-        Collection<Matchable> syncMatchables = new ArrayList<>();
-        // Assemble matchables async, then search synchronously.
-        for (int i = 0; !isComplete(plugin) && i < plugin.getSearchPollsPerTick(); ++i) {
-            ++polls;
-            // Calling #isComplete will advance to next InventoryProvider as necessary.
-            // Bucket matchables for searching synchronously.
-            syncMatchables.add(current.next());
-        }
-
-        Future<Boolean> future = plugin.getServer().getScheduler().callSyncMethod(plugin, () -> {
-            for (Matchable matchable : syncMatchables) {
-                MatchResult match = matchable.match(matcher);
-                if (match.isMatch()) {
-                    matches.addAll(Arrays.asList(match.getMatch()));
-                }
-            }
-            return true;
-        });
-
-        try {
-            future.get();
-        } catch (InterruptedException | ExecutionException e) {
-            // Eat exception to prevent spam.
-        }
-    }
-
-    private void sendProgress(CommandSender sender, OpenInv plugin) {
-        if (!(sender instanceof Player) || polls % (10 * plugin.getSearchPollsPerTick()) != 1) {
-            return;
-        }
-        double progress = 100 * Math.min(polls, totalMatchables) / totalMatchables;
-        DecimalFormat percent = new DecimalFormat("00.0");
-        plugin.sendSystemMessage((Player) sender, "messages.info.search.progress",
-                "%progress%", percent.format(progress),
-                "%matches%", String.valueOf(matches.size()));
-    }
-
-    private void sendResults(CommandSender sender, OpenInv plugin) {
-        if (matches.isEmpty()) {
-            String localizedMessage = plugin.getLocalizedMessage(sender, "messages.info.search.noMatches");
-            if (localizedMessage == null) {
-                localizedMessage = "No items found with search parameters.";
-            }
-            sender.sendMessage(localizedMessage);
-            return;
-        }
-
-        String prefix = plugin.getLocalizedMessage(sender, "messages.info.search.matches");
-        if (prefix == null) {
-            prefix = "Locations of items matching parameters:";
-        }
-
-        if (sender instanceof Player) {
-            TextComponent textComponent = new TextComponent(prefix);
-            Iterator<MessagePart> iterator = matches.iterator();
-
-            int total = 0;
-            int searchResultsMax = plugin.getSearchResultsMax();
-            while (iterator.hasNext()) {
-                textComponent.addExtra(iterator.next().forPlayer());
-
-                ++total;
-                if (total >= searchResultsMax) {
-                    break;
-                }
-
-                 if (iterator.hasNext()) {
-                     textComponent.addExtra(SEPARATOR);
-                 }
-            }
-
-            // Paper deprecated Spigot's message API.
-            // This is a risky deprecation ignore - Spigot may eventually do the sane thing
-            // and just add a method accepting components to the player directly.
-            //noinspection deprecation
-            sender.spigot().sendMessage(textComponent);
-            return;
-        }
-
-        String message = matches.stream()
-                .limit(plugin.getSearchResultsMax())
-                .map(MessagePart::forConsole)
-                .collect(Collectors.joining(", ", prefix, ""));
-        sender.sendMessage(message);
-    }
-
-    public void schedule(CommandSender sender, OpenInv plugin) {
-        new BukkitRunnable() {
-            @Override
-            public void run() {
-                // Scheduler struggles to cancel async tasks with high frequency.
-                if (isCancelled()) {
-                    return;
-                }
-
-                poll(plugin);
-
-                if (isComplete(plugin)) {
-                    if (isCancelled()) {
-                        return;
-                    }
-
-                    sendResults(sender, plugin);
-                    cancel();
-
-                    if (callback != null) {
-                        callback.run();
-                    }
-                    return;
-                }
-
-                sendProgress(sender, plugin);
-            }
-        }.runTaskTimerAsynchronously(plugin, 0L, 1L);
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/search/bucket/ChunkBucket.java

@@ -1,123 +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.search.bucket;
-
-import com.lishid.openinv.search.match.MatchResult;
-import com.lishid.openinv.search.match.Matchable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-import java.util.function.BiConsumer;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-import org.jetbrains.annotations.NotNull;
-
-public class ChunkBucket implements SearchBucket {
-
-    private final World world;
-    private final boolean load;
-    private final List<ChunkCoord> chunks;
-    protected int index = -1;
-    private Boolean paper = null;
-
-    public ChunkBucket(@NotNull World world, int chunkX, int chunkZ, int radius, boolean load) {
-        this.world = world;
-        this.load = load;
-        this.chunks = new ArrayList<>();
-        // Order chunks based (loosely) on proximity.
-        spiralRectangle(radius, (deltaX, deltaZ) -> chunks.add(new ChunkCoord(chunkX + deltaX, chunkZ + deltaZ)));
-    }
-
-    @Override
-    public @NotNull Matchable next() throws IndexOutOfBoundsException {
-        ChunkCoord chunkCoord = chunks.get(++index);
-
-        if (!world.isChunkGenerated(chunkCoord.x(), chunkCoord.z())) {
-            return Matchable.EMPTY;
-        }
-
-        if (!load && !world.isChunkLoaded(chunkCoord.x(), chunkCoord.z())) {
-            return Matchable.EMPTY;
-        }
-
-        // If async chunk loading is not available, load chunk when checking.
-        if (!isPaper()) {
-            return new MatchableChunk(world, chunkCoord.x(), chunkCoord.z());
-        }
-
-        CompletableFuture<Chunk> chunkAt = world.getChunkAtAsync(chunkCoord.x(), chunkCoord.z());
-
-        Chunk chunk;
-        try {
-            chunk = chunkAt.get();
-        } catch (InterruptedException | ExecutionException e) {
-            return matcher -> MatchResult.NO_MATCH;
-        }
-
-        return new MatchableChunk(chunk);
-    }
-
-    private boolean isPaper() {
-        if (paper == null) {
-            try {
-                // Check for Paper.
-                Class.forName("com.destroystokyo.paper.PaperConfig");
-                paper = true;
-            } catch (ClassNotFoundException e) {
-                paper = false;
-            }
-        }
-
-        return paper;
-    }
-
-    @Override
-    public boolean hasNext() {
-        return index < chunks.size() - 1;
-    }
-
-    @Override
-    public int size() {
-        return chunks.size();
-    }
-
-    /**
-     * Produce a series of integer coordinates starting at 0, 0 that extend outward to form a centered square,
-     * producing closer proximity results sooner than a traditional double for loop from min to max.
-     *
-     * @param radius the radius of the square
-     * @param coordConsumer the method consuming the values produced
-     */
-    private static void spiralRectangle(int radius, BiConsumer<Integer, Integer> coordConsumer) {
-        for (int x = 0; x <= radius; ++x) {
-            for (int z = 0; z <= radius; ++z) {
-                coordConsumer.accept(x, z);
-                if (x != 0) {
-                    coordConsumer.accept(-x, z);
-                    if (z != 0) {
-                        coordConsumer.accept(-x, -z);
-                    }
-                }
-                if (z != 0) {
-                    coordConsumer.accept(x, -z);
-                }
-            }
-        }
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/search/bucket/ChunkCoord.java

@@ -1,22 +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.search.bucket;
-
-/**
- * A data holder for chunk coordinates.
- */
-public record ChunkCoord(int x, int z) {}

plugin/src/main/java/com/lishid/openinv/search/bucket/MatchableChunk.java

@@ -1,128 +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.search.bucket;
-
-import com.lishid.openinv.search.match.ItemMatcher;
-import com.lishid.openinv.search.match.MatchResult;
-import com.lishid.openinv.search.match.Matchable;
-import com.lishid.openinv.util.MessagePart;
-import java.util.ArrayList;
-import java.util.List;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.HoverEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.chat.hover.content.Text;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-import org.bukkit.block.BlockState;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.InventoryHolder;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-class MatchableChunk implements Matchable {
-
-    private Chunk chunk;
-    private World world;
-    private int chunkX;
-    private int chunkZ;
-
-    MatchableChunk(@NotNull Chunk chunk) {
-        this.chunk = chunk;
-    }
-
-    MatchableChunk(@NotNull World world, int chunkX, int chunkZ) {
-        this.world = world;
-        this.chunkX = chunkX;
-        this.chunkZ = chunkZ;
-    }
-
-    private Chunk getChunk() {
-        if (chunk == null) {
-            chunk = world.getChunkAt(chunkX, chunkZ);
-        }
-        return chunk;
-    }
-
-    @Override
-    public @NotNull MatchResult match(@NotNull ItemMatcher matcher) {
-        List<BlockState> blocks = new ArrayList<>();
-
-        for (BlockState tileEntity : getChunk().getTileEntities()) {
-            if (!(tileEntity instanceof InventoryHolder)) {
-                continue;
-            }
-
-            Inventory inventory = ((InventoryHolder) tileEntity).getInventory();
-
-            for (ItemStack content : inventory.getContents()) {
-                if (matcher.matches(content)) {
-                    blocks.add(tileEntity);
-                    break;
-                }
-            }
-        }
-
-        if (blocks.isEmpty()) {
-            return MatchResult.NO_MATCH;
-        }
-
-        MessagePart[] matches = new MessagePart[blocks.size()];
-        for (int i = 0; i < matches.length; ++i) {
-            BlockState state = blocks.get(i);
-            matches[i] = new MessagePart(() -> getComponent(state), () -> getString(state));
-        }
-
-        return new MatchResult(matches);
-    }
-
-    private static BaseComponent getComponent(BlockState state) {
-        TextComponent component = new TextComponent(state.getType().name());
-
-        String command = String.format(
-                "/execute in %s minecraft:tp %s %s %s",
-                state.getWorld().getName(),
-                state.getX(),
-                state.getY() + 1,
-                state.getZ());
-        component.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command));
-
-        String hover = String.format(
-                "%s{world:%s,x:%s,y:%s,z:%s}\n\nClick to teleport.",
-                state.getType().getKey(),
-                state.getWorld().getName(),
-                state.getX(),
-                state.getY(),
-                state.getZ());
-        Text hoverText = new Text(new BaseComponent[] { new TextComponent(hover)});
-        component.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, hoverText));
-
-        return component;
-    }
-
-    private static String getString(BlockState state) {
-        return String.format(
-                "%s{world:%s,x:%s,y:%s,z:%s}",
-                state.getType().getKey(),
-                state.getWorld().getName(),
-                state.getX(),
-                state.getY(),
-                state.getZ());
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/search/bucket/MatchablePlayer.java

@@ -1,174 +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.search.bucket;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.search.match.ItemMatcher;
-import com.lishid.openinv.search.match.MatchResult;
-import com.lishid.openinv.search.match.Matchable;
-import com.lishid.openinv.util.MessagePart;
-import java.util.UUID;
-import java.util.function.Supplier;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.HoverEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.chat.hover.content.Text;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.entity.Player;
-import org.bukkit.event.inventory.InventoryType;
-import org.bukkit.inventory.InventoryView;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
-import org.jetbrains.annotations.NotNull;
-
-public class MatchablePlayer implements Matchable {
-
-    private final OpenInv plugin;
-    private final OfflinePlayer offlinePlayer;
-
-    public MatchablePlayer(OpenInv plugin, OfflinePlayer offlinePlayer) {
-        this.plugin = plugin;
-        this.offlinePlayer = offlinePlayer;
-    }
-
-    @Override
-    public @NotNull MatchResult match(@NotNull ItemMatcher matcher) {
-
-        Player player;
-        if (offlinePlayer instanceof Player) {
-            player = (Player) offlinePlayer;
-        } else {
-            player = plugin.loadPlayer(offlinePlayer);
-        }
-
-        if (player == null) {
-            return MatchResult.NO_MATCH;
-        }
-
-        boolean matchInv = false;
-        boolean matchEnder = false;
-
-        PlayerInventory playerInventory = player.getInventory();
-
-        // Check inventory. Modern implementations include armor and off hand in contents.
-        for (ItemStack content : playerInventory.getContents()) {
-            if (matcher.matches(content)) {
-                matchInv = true;
-                break;
-            }
-        }
-
-        InventoryView openInventory = player.getOpenInventory();
-
-        // If no matches are found yet, check cursor.
-        if (!matchInv && matcher.matches(openInventory.getCursor())) {
-            matchInv = true;
-        }
-
-        // Check player crafting inventory.
-        if (!matchInv && openInventory.getType() == InventoryType.CRAFTING) {
-            for (ItemStack content : openInventory.getTopInventory().getContents()) {
-                if (matcher.matches(content)) {
-                    matchInv = true;
-                    break;
-                }
-            }
-        }
-
-        // Check ender chest.
-        for (ItemStack content : player.getEnderChest().getContents()) {
-            if (matcher.matches(content)) {
-                matchEnder = true;
-                break;
-            }
-        }
-
-        if (!matchInv && !matchEnder) {
-            return MatchResult.NO_MATCH;
-        }
-
-        String name = player.getName();
-        UUID uuid = player.getUniqueId();
-
-        if (matchInv && matchEnder) {
-            return new MatchResult(new MessagePart[] {
-                    new MessagePart(() -> getBoth(name, uuid), () -> name + " (inv, ender)")
-            });
-        }
-
-        Supplier<BaseComponent> componentSupplier;
-        Supplier<String> stringSupplier;
-
-        if (matchInv) {
-            componentSupplier = () -> getSingle(name, () -> getInvClick(uuid), () -> getInvHover(name));
-            stringSupplier = () -> name + " (inv)";
-        } else {
-            componentSupplier = () -> getSingle(name, () -> getEnderClick(uuid), () -> getEnderHover(name));
-            stringSupplier = () -> name + " (ender)";
-        }
-
-        return new MatchResult(new MessagePart[] { new MessagePart(componentSupplier, stringSupplier) });
-    }
-
-    private static BaseComponent getBoth(String name, UUID uuid) {
-        BaseComponent component = new TextComponent(name + " (inv,");
-        component.setClickEvent(getInvClick(uuid));
-        component.setHoverEvent(getInvHover(name));
-
-        BaseComponent enderComponent = new TextComponent(" ender)");
-        enderComponent.setClickEvent(getEnderClick(uuid));
-        enderComponent.setHoverEvent(getEnderHover(name));
-
-        component.addExtra(enderComponent);
-        return component;
-    }
-
-    private static BaseComponent getSingle(String name, Supplier<ClickEvent> click, Supplier<HoverEvent> hover) {
-        BaseComponent component = new TextComponent(name);
-        component.setClickEvent(click.get());
-        component.setHoverEvent(hover.get());
-        return component;
-    }
-
-    private static ClickEvent getInvClick(UUID uuid) {
-        return getClick("/openinv:openinv ", uuid);
-    }
-
-    private static HoverEvent getInvHover(String name) {
-        return getHover("/openinv ", name);
-    }
-
-    private static ClickEvent getEnderClick(UUID uuid) {
-        return getClick("/openinv:openender ", uuid);
-    }
-
-    private static HoverEvent getEnderHover(String name) {
-        return getHover("/openender ", name);
-    }
-
-    private static ClickEvent getClick(String command, UUID uuid) {
-        // Actual command run is not exposed to user, so there's no reason not to use UUID and be precise.
-        return new ClickEvent(ClickEvent.Action.RUN_COMMAND, command + uuid);
-    }
-
-    private static HoverEvent getHover(String command, String name) {
-        BaseComponent[] text = new BaseComponent[] { new TextComponent(command + name) };
-        return new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text(text));
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/search/bucket/PlayerBucket.java

@@ -1,56 +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.search.bucket;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.search.match.Matchable;
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-public class PlayerBucket implements SearchBucket {
-
-    private final OpenInv plugin;
-    private final OfflinePlayer[] players;
-    private int index = -1;
-
-    public PlayerBucket(OpenInv plugin, boolean online) {
-        this.plugin = plugin;
-        if (online) {
-            this.players = Bukkit.getOnlinePlayers().toArray(new Player[0]);
-        } else {
-            this.players = Bukkit.getOfflinePlayers();
-        }
-    }
-
-    @Override
-    public boolean hasNext() {
-        return index < players.length - 1;
-    }
-
-    @Override
-    public @NotNull Matchable next() {
-        return new MatchablePlayer(plugin, players[++index]);
-    }
-
-    @Override
-    public int size() {
-        return 1;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/search/bucket/SearchBucket.java

@@ -1,30 +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.search.bucket;
-
-import com.lishid.openinv.search.match.Matchable;
-import org.jetbrains.annotations.NotNull;
-
-public interface SearchBucket {
-
-    boolean hasNext();
-
-    @NotNull Matchable next() throws IndexOutOfBoundsException;
-
-    int size();
-
-}

plugin/src/main/java/com/lishid/openinv/search/match/ItemMatchables.java

@@ -1,64 +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.search.match;
-
-import org.bukkit.Material;
-import org.bukkit.enchantments.Enchantment;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class ItemMatchables {
-
-    public static MatchableItem isType(@NotNull Material material) {
-        return itemStack -> itemStack.getType() == material;
-    }
-
-    public static MatchableItem hasAmount(int minAmount) {
-        return itemStack -> itemStack.getAmount() >= minAmount;
-    }
-
-    public static MatchableMeta hasEnchant(@Nullable Enchantment enchantment, @Nullable Integer minLevel) {
-        return itemMeta -> {
-            if (minLevel == null) {
-                if (enchantment == null) {
-                    // Level and enchantment not specified, any enchantment of any level matches.
-                    return !itemMeta.getEnchants().isEmpty();
-                }
-
-                // Level not specified, any level of enchantment matches.
-                return itemMeta.hasEnchant(enchantment);
-            }
-
-            if (enchantment != null) {
-                // Level and enchantment are specified, enchantment must meet or exceed level.
-                return itemMeta.getEnchantLevel(enchantment) >= minLevel;
-            }
-
-            // Enchantment not specified, any enchantment that meets or exceeds level matches.
-            for (int enchantLevel : itemMeta.getEnchants().values()) {
-                if (enchantLevel >= minLevel) {
-                    return true;
-                }
-            }
-
-            return false;
-        };
-    }
-
-    private ItemMatchables() {}
-
-}

plugin/src/main/java/com/lishid/openinv/search/match/ItemMatcher.java

@@ -1,79 +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.search.match;
-
-import java.util.Collection;
-import java.util.HashSet;
-import org.bukkit.Material;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * A collection of multiple filters used to match items.
- */
-public class ItemMatcher {
-
-    private final Collection<MatchableItem> baseOptions;
-    private final Collection<MatchableMeta> metaOptions;
-
-    public ItemMatcher(
-            Collection<MatchableItem> baseOptions,
-            Collection<MatchableMeta> metaOptions) {
-        this.baseOptions = new HashSet<>(baseOptions);
-        this.metaOptions = new HashSet<>(metaOptions);
-    }
-
-    public boolean matches(@Nullable ItemStack other) {
-        // Ensure item exists.
-        if (other == null || other.getType() == Material.AIR) {
-            return false;
-        }
-
-        // Match options against base item.
-        for (MatchableItem baseOption : baseOptions) {
-            if (!baseOption.matches(other)) {
-                return false;
-            }
-        }
-
-        // If no meta options exist, item matches.
-        if (metaOptions.isEmpty()) {
-            return true;
-        }
-
-        // Require item meta for meta options.
-        ItemMeta meta;
-        if (!other.hasItemMeta() || (meta = other.getItemMeta()) == null) {
-            return false;
-        }
-
-        // Match meta-based options.
-        for (MatchableMeta metaOption : metaOptions) {
-            if (!metaOption.matches(meta)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    public boolean isEmpty() {
-        return baseOptions.isEmpty() && metaOptions.isEmpty();
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/search/match/MatchResult.java

@@ -1,45 +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.search.match;
-
-import com.lishid.openinv.util.MessagePart;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class MatchResult {
-
-    public static final MatchResult NO_MATCH = new MatchResult();
-
-    private final MessagePart[] result;
-
-    private MatchResult() {
-        result = null;
-    }
-
-    public MatchResult(MessagePart @NotNull [] result) {
-        this.result = result;
-    }
-
-    public boolean isMatch() {
-        return result != null;
-    }
-
-    public MessagePart @Nullable [] getMatch() {
-        return result;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/search/match/Matchable.java

@@ -1,27 +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.search.match;
-
-import org.jetbrains.annotations.NotNull;
-
-public interface Matchable {
-
-    Matchable EMPTY = matcher -> MatchResult.NO_MATCH;
-
-    @NotNull MatchResult match(@NotNull ItemMatcher matcher);
-
-}

plugin/src/main/java/com/lishid/openinv/search/match/MatchableItem.java

@@ -1,26 +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.search.match;
-
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-public interface MatchableItem {
-
-    boolean matches(@NotNull ItemStack itemStack);
-
-}

plugin/src/main/java/com/lishid/openinv/search/match/MatchableMeta.java

@@ -1,26 +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.search.match;
-
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.NotNull;
-
-public interface MatchableMeta {
-
-    boolean matches(@NotNull ItemMeta itemMeta);
-
-}

plugin/src/main/java/com/lishid/openinv/util/ConfigUpdater.java

@@ -60,9 +60,6 @@ public class ConfigUpdater {
             if (version < 4) {
                 updateConfig3To4();
             }
-            if (version < 5) {
-                updateConfig4To5();
-            }
 
             plugin.getServer().getScheduler().runTask(plugin, () -> {
                 plugin.saveConfig();
@@ -71,14 +68,6 @@ public class ConfigUpdater {
         });
     }
 
-    private void updateConfig4To5() {
-        plugin.getServer().getScheduler().runTask(plugin, () -> {
-            plugin.getConfig().set("settings.search.polls-per-tick", 5);
-            plugin.getConfig().set("settings.search.max-results", 40);
-            plugin.getConfig().set("config-version", 5);
-        });
-    }
-
     private void updateConfig3To4() {
         plugin.getServer().getScheduler().runTask(plugin, () -> {
             plugin.getConfig().set("notify", null);

plugin/src/main/java/com/lishid/openinv/util/InternalAccessor.java

@@ -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
@@ -19,11 +19,13 @@ package com.lishid.openinv.util;
 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 org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
 
 public class InternalAccessor {
 
@@ -83,8 +85,6 @@ public class InternalAccessor {
             case "v1_16_R2":
                 return "https://github.com/lishid/OpenInv/releases/tag/4.1.5";
             case "v1_16_R3":
-                return "https://github.com/Jikoo/OpenInv/releases/tag/4.1.8";
-            case "v1_17_R1":
             default:
                 return "https://github.com/Jikoo/OpenInv/releases";
         }
@@ -134,6 +134,23 @@ public class InternalAccessor {
         throw new IllegalArgumentException(message);
     }
 
+    private <T extends ISpecialInventory> T createSpecialInventory(
+            @NotNull Class<? extends T> assignableClass,
+            @NotNull String className,
+            @NotNull Player player,
+            boolean online) throws InstantiationException {
+        if (!this.supported) {
+            throw new IllegalStateException(String.format("Unsupported server version %s!", this.version));
+        }
+        try {
+            return this.createObject(assignableClass, className, player, online);
+        } catch (Exception original) {
+            InstantiationException exception = new InstantiationException(String.format("Unable to create a new %s", className));
+            exception.initCause(original.fillInStackTrace());
+            throw exception;
+        }
+    }
+
     /**
      * Creates an instance of the IAnySilentContainer implementation for the current server version.
      *
@@ -189,14 +206,7 @@ public class InternalAccessor {
      * @throws InstantiationException if the ISpecialEnderChest could not be instantiated
      */
     public ISpecialEnderChest newSpecialEnderChest(final Player player, final boolean online) throws InstantiationException {
-        if (!this.supported) {
-            throw new IllegalStateException(String.format("Unsupported server version %s!", this.version));
-        }
-        try {
-            return this.createObject(ISpecialEnderChest.class, "SpecialEnderChest", player, online);
-        } catch (Exception e) {
-            throw new InstantiationException(String.format("Unable to create a new ISpecialEnderChest: %s", e.getMessage()));
-        }
+        return this.createSpecialInventory(ISpecialEnderChest.class, "SpecialEnderChest", player, online);
     }
 
     /**
@@ -208,14 +218,7 @@ public class InternalAccessor {
      * @throws InstantiationException if the ISpecialPlayerInventory could not be instantiated
      */
     public ISpecialPlayerInventory newSpecialPlayerInventory(final Player player, final boolean online) throws InstantiationException {
-        if (!this.supported) {
-            throw new IllegalStateException(String.format("Unsupported server version %s!", this.version));
-        }
-        try {
-            return this.createObject(ISpecialPlayerInventory.class, "SpecialPlayerInventory", player, online);
-        } catch (Exception e) {
-            throw new InstantiationException(String.format("Unable to create a new ISpecialPlayerInventory: %s", e.getMessage()));
-        }
+        return this.createSpecialInventory(ISpecialPlayerInventory.class, "SpecialPlayerInventory", player, online);
     }
 
 }

plugin/src/main/java/com/lishid/openinv/util/MessagePart.java

@@ -1,80 +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 java.util.List;
-import java.util.function.Supplier;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class MessagePart {
-
-    private final Supplier<BaseComponent> playerProvider;
-    private final Supplier<String> consoleProvider;
-    private @Nullable BaseComponent playerComponent;
-    private @Nullable String consoleComponent;
-
-    public MessagePart(@NotNull Supplier<@NotNull BaseComponent> playerProvider) {
-        this(playerProvider, () -> unwrapComponent(playerProvider.get()));
-    }
-
-    public MessagePart(
-            @NotNull Supplier<@NotNull BaseComponent> playerProvider,
-            @NotNull Supplier<@NotNull String> consoleProvider) {
-        this.playerProvider = playerProvider;
-        this.consoleProvider = consoleProvider;
-    }
-
-    public BaseComponent forPlayer() {
-        if (this.playerComponent == null) {
-            this.playerComponent = playerProvider.get();
-        }
-        return this.playerComponent;
-    }
-
-    public String forConsole() {
-        if (consoleComponent == null) {
-            consoleComponent = consoleProvider.get();
-        }
-        return consoleComponent;
-    }
-
-    private static String unwrapComponent(BaseComponent component) {
-        StringBuilder builder = new StringBuilder();
-        ClickEvent clickEvent = component.getClickEvent();
-
-        if (clickEvent != null) {
-            // Prefer click events, i.e. "Check out our GitHub" with a link -> raw link
-            builder.append(clickEvent.getValue());
-        } else if (component instanceof TextComponent) {
-            builder.append(((TextComponent) component).getText());
-        }
-
-        List<BaseComponent> extra = component.getExtra();
-        if (extra != null) {
-            for (BaseComponent extraComponent : extra) {
-                builder.append(unwrapComponent(extraComponent));
-            }
-        }
-
-        return builder.toString();
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/util/Permissions.java

@@ -31,10 +31,6 @@ public enum Permissions {
     ENDERCHEST("openender"),
     ENDERCHEST_ALL("openenderall"),
     SEARCH("search"),
-    SEARCH_PLAYERS_ONLINE("search.players.online"),
-    SEARCH_PLAYERS_OFFLINE("search.players.offline"),
-    SEARCH_CHUNKS_LOADED("search.chunks.loaded"),
-    SEARCH_CHUNKS_UNLOADED("search.chunks.unloaded"),
     EDITINV("editinv"),
     EDITENDER("editender"),
     OPENSELF("openself"),

plugin/src/main/java/com/lishid/openinv/util/PseudoJson.java

@@ -1,181 +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 java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A data container for JSON-esque expressions.
- *
- * <p>Ex: A ChunkBucket can be expressed <code>chunks{world:world_name,x:0,z:0,radius:10,load:true}</code>. The
- * starting "chunks" identifies it as a ChunkBucket and the content in braces contains the construction detail.
- * However, a simpler detail, such as a MatchableItem, may be specified <code>type:IRON_SWORD</code> where "type"
- * is both the identifier of the MatchableItem and the key of the sole value.
- *
- * <p>A best-effort will be made to match other start and finish demarcation techniques.
- */
-public class PseudoJson {
-
-    private static final char[] BRACE_OPEN = new char[] { '{', '[', '(' };
-    private static final char[] BRACE_CLOSE = new char[] { '}', ']', ')' };
-    private static final Set<Character> RESERVED_CHARACTERS = new HashSet<>();
-
-    static {
-        for (char brace : BRACE_OPEN) {
-            RESERVED_CHARACTERS.add(brace);
-        }
-        for (char brace : BRACE_CLOSE) {
-            RESERVED_CHARACTERS.add(brace);
-        }
-        RESERVED_CHARACTERS.add(',');
-        RESERVED_CHARACTERS.add(':');
-    }
-
-    private final String identifier;
-    private final Map<String, String> mappings;
-
-    public PseudoJson(@NotNull String identifier) {
-        this(identifier, new HashMap<>());
-    }
-
-    public PseudoJson(@NotNull String identifier, @NotNull Map<String, String> mappings) {
-        this.identifier = identifier;
-        mappings.forEach(PseudoJson::validate);
-        this.mappings = mappings;
-    }
-
-    public @NotNull String getIdentifier() {
-        return identifier;
-    }
-
-    public @NotNull Optional<String> put(@NotNull String key, @NotNull String value) {
-        validate(key, value);
-
-        return Optional.ofNullable(this.mappings.put(key, value));
-    }
-
-    public @NotNull Optional<String> get(@NotNull String key) {
-        return Optional.ofNullable(this.mappings.get(key));
-    }
-
-    public @NotNull Map<String, String> getMappings() {
-        return Collections.unmodifiableMap(mappings);
-    }
-
-    public Optional<String> remove(@NotNull String key) {
-        return Optional.ofNullable(this.mappings.get(key));
-    }
-
-    public String asString() {
-        StringBuilder builder = new StringBuilder(identifier);
-
-        builder.append('{');
-
-        for (Iterator<Map.Entry<String, String>> iterator = mappings.entrySet().iterator(); iterator.hasNext();) {
-            Map.Entry<String, String> entry = iterator.next();
-            builder.append(entry.getKey()).append(':').append(entry.getValue());
-            if (iterator.hasNext()) {
-                builder.append(',');
-            }
-        }
-
-        builder.append('}');
-
-        return builder.toString();
-    }
-
-    @Override
-    public String toString() {
-        return asString();
-    }
-
-    private static void validate(String key, String value) {
-        if (RESERVED_CHARACTERS.stream().anyMatch(character -> key.indexOf(character) >= 0 || value.indexOf(character) >= 0)) {
-            throw new IllegalArgumentException(String.format("Primitive pseudo-JSON reserves characters %s", RESERVED_CHARACTERS));
-        }
-    }
-
-    public static PseudoJson fromString(String pseudoJson) {
-        int open = -1;
-        for (char brace : BRACE_OPEN) {
-            open = pseudoJson.indexOf(brace);
-            if (open >= 0) {
-                break;
-            }
-        }
-
-        String identifier = getIdentifier(pseudoJson, open);
-
-        int close = -1;
-        for (char brace : BRACE_CLOSE) {
-            close = pseudoJson.lastIndexOf(brace);
-            if (close >= 0) {
-                break;
-            }
-        }
-
-        if (open >= 0) {
-            if (close <= open) {
-                // Ignore bad ending brace.
-                pseudoJson = pseudoJson.substring(open + 1);
-            } else {
-                // Use only bracketed content
-                pseudoJson = pseudoJson.substring(open + 1, close);
-            }
-        }
-
-        return new PseudoJson(identifier, getMappings(pseudoJson));
-    }
-
-    private static String getIdentifier(String pseudoJson, int braceOpen) {
-        int identifierEnd;
-        if (braceOpen >= 0) {
-            identifierEnd = braceOpen;
-        } else {
-            // No quote, use first mapping.
-            identifierEnd = pseudoJson.indexOf(':');
-            if (identifierEnd == -1) {
-                // No mappings, use whole string.
-                return pseudoJson;
-            }
-        }
-
-        return pseudoJson.substring(0, identifierEnd);
-    }
-
-    private static Map<String, String> getMappings(String pseudoJson) {
-        String[] mappings = pseudoJson.split(",");
-
-        Map<String, String> data = new HashMap<>();
-        for (String mapping : mappings) {
-            String[] datum = mapping.split(":");
-            if (datum.length >= 2) {
-                data.put(datum[0], datum[1]);
-            }
-        }
-
-        return data;
-    }
-
-}

plugin/src/main/java/com/lishid/openinv/util/TabCompleter.java

@@ -22,12 +22,9 @@ import java.util.List;
 import java.util.Locale;
 import java.util.function.Function;
 import org.bukkit.Bukkit;
-import org.bukkit.Keyed;
-import org.bukkit.Material;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
 
 /**
  * Utility class for common tab completions.
@@ -40,7 +37,7 @@ public class TabCompleter {
      * @param argument the argument to complete
      * @return integer options
      */
-    public static List<String> completeInteger(@NotNull String argument) {
+    public static List<String> completeInteger(String argument) {
         // Ensure existing argument is actually a number
         if (!argument.isEmpty()) {
             try {
@@ -65,46 +62,14 @@ public class TabCompleter {
      * @param enumClazz the Enum to complete for
      * @return the matching Enum values
      */
-    public static List<String> completeEnum(@NotNull String argument, @NotNull Class<? extends Enum<?>> enumClazz) {
-        return completeObject(argument, Enum::name, enumClazz.getEnumConstants());
-    }
-
-    /**
-     * Offer tab completions for {@link Material Materials}.
-     *
-     * @param argument the argument to complete
-     * @return the matching {@code Material} keys
-     */
-    public static List<String> completeMaterial(@NotNull String argument) {
+    public static List<String> completeEnum(String argument, Class<? extends Enum<?>> enumClazz) {
         argument = argument.toLowerCase(Locale.ENGLISH);
         List<String> completions = new ArrayList<>();
 
-        for (Material material : Material.values()) {
-            if (material.name().toLowerCase(Locale.ENGLISH).startsWith(argument)
-                    || material.getKey().toString().startsWith(argument)
-                    || material.getKey().getKey().startsWith(argument)) {
-                completions.add(material.getKey().toString());
-            }
-        }
-
-        return completions;
-    }
-
-    /**
-     * Offer tab completions for {@link Keyed} values.
-     *
-     * @param argument the argument to complete
-     * @param options the {@code Keyed} values
-     * @return the matching keys
-     */
-    public static List<String> completeKeyed(@NotNull String argument, @NotNull Keyed @NotNull [] options) {
-        argument = argument.toLowerCase(Locale.ENGLISH);
-        List<String> completions = new ArrayList<>();
-
-        for (Keyed keyed : options) {
-            if (keyed.getKey().toString().startsWith(argument)
-                    || keyed.getKey().getKey().startsWith(argument)) {
-                completions.add(keyed.getKey().toString());
+        for (Enum<?> enumConstant : enumClazz.getEnumConstants()) {
+            String name = enumConstant.name().toLowerCase();
+            if (name.startsWith(argument)) {
+                completions.add(name);
             }
         }
 
@@ -118,7 +83,7 @@ public class TabCompleter {
      * @param options the Strings which may be completed
      * @return the matching Strings
      */
-    public static List<String> completeString(@NotNull String argument, @NotNull String @NotNull [] options) {
+    public static List<String> completeString(String argument, String[] options) {
         argument = argument.toLowerCase(Locale.ENGLISH);
         List<String> completions = new ArrayList<>();
 
@@ -138,7 +103,7 @@ public class TabCompleter {
      * @param argument the argument to complete
      * @return the matching Players' names
      */
-    public static List<String> completeOnlinePlayer(@NotNull CommandSender sender, String argument) {
+    public static List<String> completeOnlinePlayer(CommandSender sender, String argument) {
         List<String> completions = new ArrayList<>();
         Player senderPlayer = sender instanceof Player ? (Player) sender : null;
 
@@ -163,12 +128,12 @@ public class TabCompleter {
      * @param options the Objects which may be completed
      * @return the matching Strings
      */
-    public static <T> List<String> completeObject(@NotNull String argument, @NotNull Function<T, String> converter, @NotNull T @NotNull [] options) {
+    public static <T> List<String> completeObject(String argument, Function<T, String> converter, T[] options) {
         argument = argument.toLowerCase(Locale.ENGLISH);
         List<String> completions = new ArrayList<>();
 
         for (T option : options) {
-            String optionString = converter.apply(option).toLowerCase(Locale.ENGLISH);
+            String optionString = converter.apply(option).toLowerCase();
             if (optionString.startsWith(argument)) {
                 completions.add(optionString);
             }

plugin/src/main/resources/config.yml

@@ -1,7 +1,4 @@
-config-version: 5
+config-version: 4
 settings:
-  search:
-    polls-per-tick: 5
-    max-results: 40
   disable-saving: false
   locale: 'en_us'

plugin/src/main/resources/en_us.yml

@@ -2,11 +2,6 @@ messages:
   error:
     consoleUnsupported: 'You cannot use this command from console.'
     lootNotGenerated: '&cLoot not generated! Please disable &b/silentcontainer&c.'
-    search:
-      invalidSchema: '&cUnable to parse "%value%" to determine target. Try using tab completion!'
-      invalidInventory: '&cUnable to determine target inventories. Try using tab completion!'
-      invalidMatcher: '&cUnable to determine target item parameters. Try using tab completion!'
-      activeSearch: '&cPlease wait for your search to complete before starting another.'
     invalidMaterial: '&cInvalid material: "%target%"'
     invalidNumber: '&cInvalid number: "%target%"'
     invalidPlayer: '&cPlayer not found!'
@@ -22,10 +17,12 @@ messages:
     containerBlockedSilent: 'You are opening a blocked container silently.'
     containerSilent: 'You are opening a container silently.'
     settingState: '%setting%: %state%'
-    search:
-      progress: 'Searching... %progress%% | Results: %matches%'
-      noMatches: 'No items found with search parameters.'
-      matches: 'Locations of items matching parameters: '
+    player:
+      noMatches: 'No players found with %target%.'
+      matches: 'Players holding %target%: %detail%'
+    container:
+      noMatches: 'No containers found with %target%.'
+      matches: 'Containers holding %target%: %detail%'
     on: 'on'
     off: 'off'
 container:

plugin/src/main/resources/plugin.yml

@@ -52,12 +52,12 @@ commands:
     permission: OpenInv.openender
     usage: |-
            /<command> [Player] - Open a player's enderchest
-  search:
-    aliases: [ searchinv, si, searchender, se, searchenchant, searchenchants, searchcontainer, searchchest ]
-    description: Search inventories for a matching item
+  searchinv:
+    aliases: [si]
+    description: Search and list players having a specific item
     permission: OpenInv.search
     usage: |-
-           /<command> <inventories> <item details>
+           /<command> <Material> [MinAmount] - MinAmount is optional, the minimum amount required
   searchender:
     aliases: [se]
     permission: OpenInv.search
@@ -76,3 +76,14 @@ commands:
     permission: OpenInv.anychest
     usage: |-
            /<command> [check|on|off] - Check, toggle, or set AnyContainer
+  searchenchant:
+    aliases: [searchenchants]
+    description: Search and list players with a specific enchantment.
+    permission: OpenInv.searchenchant
+    usage: |-
+           /<command> <[Enchantment] [MinLevel]> - Enchantment is the enchantment type, MinLevel is the minimum level. One is optional
+  searchcontainer:
+    aliases: [searchchest]
+    description: Search and list containers with a specific material.
+    permission: OpenInv.searchcontainer
+    usage: /<command> <Material> [ChunkRadius] - ChunkRadius is optional, the length that will be searched for matching items. Default 5

pom.xml

@@ -27,8 +27,8 @@
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.source>16</maven.compiler.source>
-    <maven.compiler.target>16</maven.compiler.target>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
 
   <profiles>
@@ -37,8 +37,8 @@
       <modules>
         <module>api</module>
         <module>plugin</module>
+        <module>internal/v1_16_R3</module>
         <module>internal/v1_17_R1</module>
-        <module>internal/v1_18_R1</module>
         <module>assembly</module>
       </modules>
     </profile>
@@ -61,14 +61,6 @@
       <id>spigot-repo</id>
       <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
     </repository>
-    <repository>
-      <id>papermc</id>
-      <url>https://papermc.io/repo/repository/maven-public/</url>
-    </repository>
-    <repository>
-      <id>jitpack</id>
-      <url>https://jitpack.io</url>
-    </repository>
   </repositories>
 
   <dependencyManagement>
@@ -77,25 +69,13 @@
         <artifactId>annotations</artifactId>
         <groupId>org.jetbrains</groupId>
         <scope>provided</scope>
-        <version>23.0.0</version>
-      </dependency>
-      <dependency>
-        <artifactId>paper-api</artifactId>
-        <groupId>io.papermc.paper</groupId>
-        <scope>provided</scope>
-        <version>1.17.1-R0.1-SNAPSHOT</version>
+        <version>21.0.1</version>
       </dependency>
       <dependency>
         <artifactId>spigot-api</artifactId>
         <groupId>org.spigotmc</groupId>
         <scope>provided</scope>
-        <version>1.17.1-R0.1-SNAPSHOT</version>
-      </dependency>
-      <dependency>
-        <artifactId>planarwrappers</artifactId>
-        <groupId>com.github.jikoo</groupId>
-        <scope>compile</scope>
-        <version>2.2.4</version>
+        <version>1.16.5-R0.1-SNAPSHOT</version>
       </dependency>
       <dependency>
         <artifactId>openinvapi</artifactId>
@@ -112,13 +92,6 @@
     </dependencies>
   </dependencyManagement>
 
-  <pluginRepositories>
-    <pluginRepository>
-      <id>apache-snapshot-repo</id>
-      <url>https://repository.apache.org/content/repositories/snapshots/</url>
-    </pluginRepository>
-  </pluginRepositories>
-
   <build>
     <pluginManagement>
       <plugins>
@@ -152,7 +125,7 @@
             </execution>
           </executions>
           <groupId>org.apache.maven.plugins</groupId>
-          <version>3.3.1-SNAPSHOT</version>
+          <version>3.2.4</version>
         </plugin>
 
         <plugin>
@@ -166,12 +139,6 @@
           <groupId>org.apache.maven.plugins</groupId>
           <version>3.3.0</version>
         </plugin>
-
-        <plugin>
-          <groupId>net.md-5</groupId>
-          <artifactId>specialsource-maven-plugin</artifactId>
-          <version>1.2.2</version>
-        </plugin>
       </plugins>
     </pluginManagement>
   </build>

scripts/get_spigot_versions.sh

@@ -15,32 +15,21 @@
 # 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>")
@@ -59,6 +48,3 @@ for module in "${modules[@]}"; do
     fi
   done
 done
-
-# Reset JVM parameters
-export MAVEN_OPTS=$old_maven_opts

scripts/install_spigot_dependencies.sh

@@ -33,20 +33,15 @@ 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.
-# Note that the default SuperPOM declares maven-dependency-plugin 2.8.0.
-# Unfortunately, we run into MDEP-204 and require a version >= 3.1.2.
-mvn org.apache.maven.plugins:maven-dependency-plugin:3.2.0:go-offline -DexcludeArtifactIds=spigot
-
 for version in "${versions[@]}"; do
   set -e
   exit_code=0
-  mvn dependency:get -Dartifact=org.spigotmc:spigot:"$version":remapped-mojang -q -o || exit_code=$?
+  mvn dependency:get -Dartifact=org.spigotmc:spigot:"$version" -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" --remapped
+    java -jar $buildtools -rev "$revision"
   else
     echo Spigot "$version" is already installed
   fi