ShulkerBoxCeption.java

import net.menoni.rd.RuntimeDebugger;
import net.menoni.rd.model.Debugger;
import net.menoni.wimlex.addons.Beans;
import net.minecraft.server.v1_14_R1.BlockPosition;
import net.minecraft.server.v1_14_R1.Blocks;
import net.minecraft.server.v1_14_R1.Packet;
import net.minecraft.server.v1_14_R1.PacketPlayOutBlockAction;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.craftbukkit.v1_14_R1.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_14_R1.inventory.CraftInventoryCustom;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.InventoryView;
import org.bukkit.inventory.ItemStack;

import java.util.*;
import java.util.function.Consumer;

public class ShulkerBoxCeption implements Debugger, Debugger.Stoppable, Listener {

	private Player p;
	private UUID uuid;

	@Override
	public void debug(RuntimeDebugger plugin, CommandSender cs) {
		if (!(cs instanceof Player)) {
			cs.sendMessage("nop");
			return;
		}
		p = (Player) cs;
		uuid = p.getUniqueId();
	}

	@Override
	public void stop() {

	}

	private void msg(String msg, Object... args) {
		if (args != null && args.length > 0) {
			msg = String.format(msg, args);
		}
		if (p == null || !p.isOnline()) {
			p = Bukkit.getPlayer(uuid);
			if (p == null) {
				return;
			}
		}
		p.sendMessage(msg);
	}

	private Inventory currentFakeShulkerBox;
	private Inventory currentRealShulkerBox;

	@EventHandler
	public void onShulkerOpen(InventoryOpenEvent event) throws Exception {
		if (!event.getPlayer().getUniqueId().equals(uuid)) {
			return;
		}
		if (event.getInventory().getType() != InventoryType.SHULKER_BOX) {
			return;
		}
		if (event.getInventory() instanceof DelegatingInventory) {
			return;
		}
		int size = event.getInventory().getViewers().size();
		this.currentRealShulkerBox = event.getInventory();
		this.currentFakeShulkerBox = new DelegatingInventory(event.getInventory(), event.getView());
		event.getView().close();
		Bukkit.getScheduler().runTask(Beans.getPlugin(), () ->{
			event.getPlayer().openInventory(this.currentFakeShulkerBox);
			msg("sending out size: "+ size);
			PacketPlayOutBlockAction blockAction = new PacketPlayOutBlockAction(new BlockPosition(
					event.getInventory().getLocation().getBlockX(),
					event.getInventory().getLocation().getBlockY(),
					event.getInventory().getLocation().getBlockZ()
			), Blocks.SHULKER_BOX, 1, Math.max(1, size));
			sendPacket(event.getInventory().getLocation(), blockAction);
		});
	}
	
	public void sendPacket(Location loc, Packet<?> packet) {
		for (Player player : loc.getWorld().getPlayers()) {
			if (player.getLocation().distance(loc) < 128) {
				((CraftPlayer)player).getHandle().playerConnection.sendPacket(packet);
			}
		}
	}

	@EventHandler
	public void onShulkerClose(InventoryCloseEvent event) {
		if (!event.getPlayer().getUniqueId().equals(uuid)) {
			return;
		}
		if (currentFakeShulkerBox != event.getInventory()) {
			return;
		}
		if (currentRealShulkerBox != null) {
			List<HumanEntity> viewers = new ArrayList<>(currentRealShulkerBox.getViewers());
			viewers.removeIf((e) -> e.getUniqueId().equals(uuid));
			
			PacketPlayOutBlockAction action = new PacketPlayOutBlockAction(new BlockPosition(
					event.getInventory().getLocation().getBlockX(),
					event.getInventory().getLocation().getBlockY(),
					event.getInventory().getLocation().getBlockZ()
			), Blocks.SHULKER_BOX, 1, viewers.size());
			sendPacket(event.getInventory().getLocation(), action);
			currentFakeShulkerBox = null;
			currentRealShulkerBox = null;
		}
	}

	public static class DelegatingInventory extends CraftInventoryCustom {
		Inventory original;

		public DelegatingInventory(Inventory original, InventoryView view) {
			super(original.getHolder(), InventoryType.CHEST, view.getTitle());
			this.original = original;
		}

		@Override
		public int getSize() {
			return original.getSize();
		}

		@Override
		public int getMaxStackSize() {
			return original.getMaxStackSize();
		}

		@Override
		public void setMaxStackSize(int size) {
			original.setMaxStackSize(size);
		}

		@Override
		public ItemStack getItem(int index) {
			return original.getItem(index);
		}

		@Override
		public void setItem(int index, ItemStack item) {
			original.setItem(index, item);
		}

		@Override
		public HashMap<Integer, ItemStack> addItem(ItemStack... items) throws IllegalArgumentException {
			return original.addItem(items);
		}

		@Override
		public HashMap<Integer, ItemStack> removeItem(ItemStack... items) throws IllegalArgumentException {
			return original.removeItem(items);
		}

		@Override
		public ItemStack[] getContents() {
			return original.getContents();
		}

		@Override
		public void setContents(ItemStack[] items) throws IllegalArgumentException {
			original.setContents(items);
		}

		@Override
		public ItemStack[] getStorageContents() {
			return original.getStorageContents();
		}

		@Override
		public void setStorageContents(ItemStack[] items) throws IllegalArgumentException {
			original.setStorageContents(items);
		}

		@Override
		public boolean contains(Material material) throws IllegalArgumentException {
			return original.contains(material);
		}

		@Override
		public boolean contains(ItemStack item) {
			return original.contains(item);
		}

		@Override
		public boolean contains(Material material, int amount) throws IllegalArgumentException {
			return original.contains(material, amount);
		}

		@Override
		public boolean contains(ItemStack item, int amount) {
			return original.contains(item, amount);
		}

		@Override
		public boolean containsAtLeast(ItemStack item, int amount) {
			return original.containsAtLeast(item, amount);
		}

		@Override
		public HashMap<Integer, ItemStack> all(Material material) throws IllegalArgumentException {
			return (HashMap<Integer, ItemStack>) original.all(material);
		}

		@Override
		public HashMap<Integer, ItemStack> all(ItemStack item) {
			return (HashMap<Integer, ItemStack>) original.all(item);
		}

		@Override
		public int first(Material material) throws IllegalArgumentException {
			return original.first(material);
		}

		@Override
		public int first(ItemStack item) {
			return original.first(item);
		}

		@Override
		public int firstEmpty() {
			return original.firstEmpty();
		}

		@Override
		public void remove(Material material) throws IllegalArgumentException {
			original.remove(material);
		}

		@Override
		public void remove(ItemStack item) {
			original.remove(item);
		}

		@Override
		public void clear(int index) {
			original.clear(index);
		}

		@Override
		public void clear() {
			original.clear();
		}

		@Override
		public List<HumanEntity> getViewers() {
			return original.getViewers();
		}

		@Override
		public InventoryType getType() {
			return InventoryType.SHULKER_BOX;
		}

		@Override
		public InventoryHolder getHolder() {
			return original.getHolder();
		}

		@Override
		public ListIterator<ItemStack> iterator() {
			return original.iterator();
		}

		@Override
		public ListIterator<ItemStack> iterator(int index) {
			return original.iterator(index);
		}

		@Override
		public Location getLocation() {
			return original.getLocation();
		}

		@Override
		public void forEach(Consumer<? super ItemStack> action) {
			original.forEach(action);
		}

		@Override
		public Spliterator<ItemStack> spliterator() {
			return original.spliterator();
		}
	}


}