diff --git a/internal/pom.xml b/internal/pom.xml index 38ea425..28d97f9 100644 --- a/internal/pom.xml +++ b/internal/pom.xml @@ -1,5 +1,5 @@ - + + 4.0.0 @@ -32,6 +32,7 @@ v1_9_R2 v1_10_R1 v1_11_R1 + v1_12_R1 @@ -60,9 +61,10 @@ v1_9_R2 v1_10_R1 v1_11_R1 + v1_12_R1 - + \ No newline at end of file diff --git a/internal/v1_12_R1/pom.xml b/internal/v1_12_R1/pom.xml new file mode 100644 index 0000000..9d4fe00 --- /dev/null +++ b/internal/v1_12_R1/pom.xml @@ -0,0 +1,28 @@ + + 4.0.0 + + + com.lishid + openinvinternal + 3.1.3-SNAPSHOT + + + openinvadapter1_12_R1 + OpenInvAdapter1_12_R1 + + + + org.spigotmc + spigot + 1.12-R0.1-SNAPSHOT + provided + + + com.lishid + openinvcommon + 3.1.3-SNAPSHOT + + + + diff --git a/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/AnySilentContainer.java b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/AnySilentContainer.java new file mode 100644 index 0000000..cd84341 --- /dev/null +++ b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/AnySilentContainer.java @@ -0,0 +1,284 @@ +/* + * Copyright (C) 2011-2014 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 + * . + */ + +package com.lishid.openinv.internal.v1_12_R1; + +import com.lishid.openinv.internal.IAnySilentContainer; + +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.block.BlockState; +import org.bukkit.entity.Player; +import org.bukkit.scheduler.BukkitRunnable; + +import net.minecraft.server.v1_12_R1.AxisAlignedBB; +import net.minecraft.server.v1_12_R1.Block; +import net.minecraft.server.v1_12_R1.BlockChest; +import net.minecraft.server.v1_12_R1.BlockEnderChest; +import net.minecraft.server.v1_12_R1.BlockPosition; +import net.minecraft.server.v1_12_R1.BlockShulkerBox; +import net.minecraft.server.v1_12_R1.Container; +import net.minecraft.server.v1_12_R1.Entity; +import net.minecraft.server.v1_12_R1.EntityOcelot; +import net.minecraft.server.v1_12_R1.EntityPlayer; +import net.minecraft.server.v1_12_R1.EnumDirection; +import net.minecraft.server.v1_12_R1.IBlockData; +import net.minecraft.server.v1_12_R1.ITileInventory; +import net.minecraft.server.v1_12_R1.InventoryEnderChest; +import net.minecraft.server.v1_12_R1.InventoryLargeChest; +import net.minecraft.server.v1_12_R1.PacketPlayOutOpenWindow; +import net.minecraft.server.v1_12_R1.StatisticList; +import net.minecraft.server.v1_12_R1.TileEntity; +import net.minecraft.server.v1_12_R1.TileEntityChest; +import net.minecraft.server.v1_12_R1.TileEntityEnderChest; +import net.minecraft.server.v1_12_R1.TileEntityShulkerBox; +import net.minecraft.server.v1_12_R1.World; + +import org.bukkit.craftbukkit.v1_12_R1.event.CraftEventFactory; + +public class AnySilentContainer implements IAnySilentContainer { + + @Override + public boolean activateContainer(final Player p, final boolean silentchest, + final org.bukkit.block.Block b) { + + EntityPlayer player = PlayerDataManager.getHandle(p); + + // Silent ender chest is pretty much API-only + if (silentchest && b.getType() == Material.ENDER_CHEST) { + p.openInventory(p.getEnderChest()); + player.b(StatisticList.getStatistic("stat.enderchestOpened")); + return true; + } + + final World world = player.world; + final BlockPosition blockPosition = new BlockPosition(b.getX(), b.getY(), b.getZ()); + final Object 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(enderChest); + player.b(StatisticList.getStatistic("stat.enderchestOpened")); + return true; + } + + if (!(tile instanceof ITileInventory)) { + return false; + } + + ITileInventory tileInventory = (ITileInventory) tile; + Block block = world.getType(blockPosition).getBlock(); + Container container = null; + + if (block instanceof BlockChest) { + for (EnumDirection localEnumDirection : EnumDirection.EnumDirectionLimit.HORIZONTAL) { + BlockPosition localBlockPosition = blockPosition.shift(localEnumDirection); + Block localBlock = world.getType(localBlockPosition).getBlock(); + + if (localBlock != block) { + continue; + } + + TileEntity localTileEntity = world.getTileEntity(localBlockPosition); + if (!(localTileEntity instanceof TileEntityChest)) { + continue; + } + + if (localEnumDirection == EnumDirection.WEST + || localEnumDirection == EnumDirection.NORTH) { + tileInventory = new InventoryLargeChest("container.chestDouble", + (TileEntityChest) localTileEntity, tileInventory); + } else { + tileInventory = new InventoryLargeChest("container.chestDouble", tileInventory, + (TileEntityChest) localTileEntity); + } + break; + } + + BlockChest blockChest = (BlockChest) block; + if (blockChest.g == BlockChest.Type.BASIC) { + player.b(StatisticList.getStatistic("stat.chestOpened")); + } else if (blockChest.g == BlockChest.Type.TRAP) { + player.b(StatisticList.getStatistic("stat.trappedChestTriggered")); + } + + if (silentchest) { + container = new SilentContainerChest(player.inventory, tileInventory, player); + } + } + + if (block instanceof BlockShulkerBox) { + player.b(StatisticList.getStatistic("stat.shulkerBoxOpened")); + + if (silentchest && tileInventory instanceof TileEntityShulkerBox) { + // Set value to current + 1. Ensures consistency later when resetting. + SilentContainerShulkerBox.setOpenValue((TileEntityShulkerBox) tileInventory, + SilentContainerShulkerBox.getOpenValue((TileEntityShulkerBox) tileInventory) + + 1); + + container = new SilentContainerShulkerBox(player.inventory, tileInventory, player); + } + } + + // AnyChest only - SilentChest not active or container unsupported + if (!silentchest || container == null) { + player.openContainer(tileInventory); + return true; + } + + // SilentChest + try { + // Call InventoryOpenEvent + container = CraftEventFactory.callInventoryOpenEvent(player, container, false); + if (container == null) { + return false; + } + + // Open window + int windowId = player.nextContainerCounter(); + player.playerConnection.sendPacket( + new PacketPlayOutOpenWindow(windowId, tileInventory.getContainerName(), + tileInventory.getScoreboardDisplayName(), tileInventory.getSize())); + player.activeContainer = container; + player.activeContainer.windowId = windowId; + player.activeContainer.addSlotListener(player); + + // Special handling for shulker boxes - reset value for viewers to what it was + // initially. + if (tile instanceof TileEntityShulkerBox) { + new BukkitRunnable() { + @Override + public void run() { + // TODO hacky + Object tile = world.getTileEntity(blockPosition); + if (!(tile instanceof TileEntityShulkerBox)) { + return; + } + TileEntityShulkerBox box = (TileEntityShulkerBox) tile; + // Reset back - we added 1, and calling TileEntityShulkerBox#startOpen adds + // 1 more. + SilentContainerShulkerBox.setOpenValue(box, + SilentContainerShulkerBox.getOpenValue((TileEntityShulkerBox) tile) + - 2); + } + }.runTaskLater(Bukkit.getPluginManager().getPlugin("OpenInv"), 2); + } + + return true; + } catch (Exception e) { + e.printStackTrace(); + p.sendMessage(ChatColor.RED + "Error while sending silent container."); + return false; + } + } + + private boolean hasOcelotOnTop(final World world, final BlockPosition blockPosition) { + for (Entity localEntity : world.a(EntityOcelot.class, + new AxisAlignedBB(blockPosition.getX(), blockPosition.getY() + 1, + blockPosition.getZ(), blockPosition.getX() + 1, blockPosition.getY() + 2, + blockPosition.getZ() + 1))) { + EntityOcelot localEntityOcelot = (EntityOcelot) localEntity; + if (localEntityOcelot.isSitting()) { + return true; + } + } + + return false; + } + + @Override + public boolean isAnyContainerNeeded(final Player p, final org.bukkit.block.Block b) { + EntityPlayer player = PlayerDataManager.getHandle(p); + World world = player.world; + BlockPosition blockPosition = new BlockPosition(b.getX(), b.getY(), b.getZ()); + IBlockData blockData = world.getType(blockPosition); + Block block = blockData.getBlock(); + + if (block instanceof BlockShulkerBox) { + return this.isBlockedShulkerBox(world, blockPosition, blockData); + } + + if (block instanceof BlockEnderChest) { + // Ender chests are not blocked by ocelots. + return world.getType(blockPosition.up()).m(); + } + + // Check if chest is blocked or has an ocelot on top + if (this.isBlockedChest(world, blockPosition)) { + return true; + } + + // Check for matching adjacent chests that are blocked or have an ocelot on top + for (EnumDirection localEnumDirection : EnumDirection.EnumDirectionLimit.HORIZONTAL) { + BlockPosition localBlockPosition = blockPosition.shift(localEnumDirection); + Block localBlock = world.getType(localBlockPosition).getBlock(); + + if (localBlock != block) { + continue; + } + + TileEntity localTileEntity = world.getTileEntity(localBlockPosition); + if (!(localTileEntity instanceof TileEntityChest)) { + continue; + } + + if (this.isBlockedChest(world, localBlockPosition)) { + return true; + } + } + + return false; + } + + @Override + public boolean isAnySilentContainer(final org.bukkit.block.Block block) { + if (block.getType() == Material.ENDER_CHEST) { + return true; + } + BlockState state = block.getState(); + return state instanceof org.bukkit.block.Chest + || state instanceof org.bukkit.block.ShulkerBox; + } + + private boolean isBlockedChest(final World world, final BlockPosition blockPosition) { + // For reference, loot at net.minecraft.server.BlockChest + return world.getType(blockPosition.up()).m() || this.hasOcelotOnTop(world, blockPosition); + } + + private boolean isBlockedShulkerBox(final World world, final BlockPosition blockPosition, + final IBlockData blockData) { + // For reference, look at net.minecraft.server.BlockShulkerBox + TileEntity tile = world.getTileEntity(blockPosition); + + if (!(tile instanceof TileEntityShulkerBox)) { + return false; + } + + EnumDirection enumDirection = blockData.get(BlockShulkerBox.a); + if (((TileEntityShulkerBox) tile).p() == TileEntityShulkerBox.AnimationPhase.CLOSED) { + AxisAlignedBB axisAlignedBB = Block.j.b(0.5F * enumDirection.getAdjacentX(), + 0.5F * enumDirection.getAdjacentY(), 0.5F * enumDirection.getAdjacentZ()) + .a(enumDirection.getAdjacentX(), enumDirection.getAdjacentY(), + enumDirection.getAdjacentZ()); + + return world.a(axisAlignedBB.a(blockPosition.shift(enumDirection))); + } + + return false; + } + +} diff --git a/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/InventoryAccess.java b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/InventoryAccess.java new file mode 100644 index 0000000..0da8f58 --- /dev/null +++ b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/InventoryAccess.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2011-2014 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 + * . + */ + +package com.lishid.openinv.internal.v1_12_R1; + +import com.lishid.openinv.internal.IInventoryAccess; +import com.lishid.openinv.internal.ISpecialEnderChest; +import com.lishid.openinv.internal.ISpecialPlayerInventory; +import com.lishid.openinv.util.InternalAccessor; + +import org.bukkit.inventory.Inventory; + +import net.minecraft.server.v1_12_R1.IInventory; + +import org.bukkit.craftbukkit.v1_12_R1.inventory.CraftInventory; + +public class InventoryAccess implements IInventoryAccess { + + @Override + public ISpecialEnderChest getSpecialEnderChest(final Inventory inventory) { + IInventory inv; + if (inventory instanceof CraftInventory) { + inv = ((CraftInventory) inventory).getInventory(); + } else { + inv = InternalAccessor.grabFieldOfTypeFromObject(IInventory.class, inventory); + } + + if (inv instanceof SpecialEnderChest) { + return (SpecialEnderChest) inv; + } + return null; + } + + @Override + public ISpecialPlayerInventory getSpecialPlayerInventory(final Inventory inventory) { + IInventory inv; + if (inventory instanceof CraftInventory) { + inv = ((CraftInventory) inventory).getInventory(); + } else { + inv = InternalAccessor.grabFieldOfTypeFromObject(IInventory.class, inventory); + } + + if (inv instanceof SpecialPlayerInventory) { + return (SpecialPlayerInventory) inv; + } + return null; + } + + @Override + public boolean isSpecialEnderChest(final Inventory inventory) { + if (inventory instanceof CraftInventory) { + return ((CraftInventory) inventory).getInventory() instanceof ISpecialEnderChest; + } + return InternalAccessor.grabFieldOfTypeFromObject(IInventory.class, + inventory) instanceof ISpecialEnderChest; + } + + @Override + public boolean isSpecialPlayerInventory(final Inventory inventory) { + if (inventory instanceof CraftInventory) { + return ((CraftInventory) inventory).getInventory() instanceof ISpecialPlayerInventory; + } + return InternalAccessor.grabFieldOfTypeFromObject(IInventory.class, + inventory) instanceof ISpecialPlayerInventory; + } + +} diff --git a/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/PlayerDataManager.java b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/PlayerDataManager.java new file mode 100644 index 0000000..6c83edd --- /dev/null +++ b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/PlayerDataManager.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2011-2014 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 + * . + */ + +package com.lishid.openinv.internal.v1_12_R1; + +import java.util.Collection; +import java.util.UUID; + +import com.lishid.openinv.internal.IPlayerDataManager; + +import com.mojang.authlib.GameProfile; + +import org.bukkit.Bukkit; +import org.bukkit.OfflinePlayer; +import org.bukkit.Server; +import org.bukkit.entity.Player; + +import net.minecraft.server.v1_12_R1.EntityPlayer; +import net.minecraft.server.v1_12_R1.MinecraftServer; +import net.minecraft.server.v1_12_R1.PlayerInteractManager; + +import org.bukkit.craftbukkit.v1_12_R1.CraftServer; +import org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer; + +public class PlayerDataManager implements IPlayerDataManager { + + public static EntityPlayer getHandle(final Player player) { + if (player instanceof CraftPlayer) { + return ((CraftPlayer) player).getHandle(); + } + + Server server = player.getServer(); + EntityPlayer nmsPlayer = null; + + if (server instanceof CraftServer) { + nmsPlayer = ((CraftServer) server).getHandle().getPlayer(player.getName()); + } + + if (nmsPlayer == null) { + // Could use reflection to examine fields, but it's honestly not worth the bother. + throw new RuntimeException( + "Unable to fetch EntityPlayer from provided Player implementation"); + } + + return nmsPlayer; + } + + @Override + public Collection getOnlinePlayers() { + return Bukkit.getOnlinePlayers(); + } + + @Override + public OfflinePlayer getPlayerByID(final String identifier) { + try { + UUID uuid = UUID.fromString(identifier); + OfflinePlayer player = Bukkit.getOfflinePlayer(uuid); + // Ensure player is a real player, otherwise return null + if (player == null || !player.hasPlayedBefore() && !player.isOnline()) { + return null; + } + return player; + } catch (IllegalArgumentException e) { + // Not a UUID + return null; + } + } + + @Override + public String getPlayerDataID(final OfflinePlayer player) { + return player.getUniqueId().toString(); + } + + @Override + public Player loadPlayer(final OfflinePlayer offline) { + // Ensure player has data + if (offline == null || !offline.hasPlayedBefore()) { + return null; + } + + // Create a profile and entity to load the player data + GameProfile profile = new GameProfile(offline.getUniqueId(), offline.getName()); + MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer(); + EntityPlayer entity = new EntityPlayer(server, server.getWorldServer(0), profile, + new PlayerInteractManager(server.getWorldServer(0))); + + // Get the bukkit entity + Player target = entity == null ? null : entity.getBukkitEntity(); + if (target != null) { + // Load data + target.loadData(); + } + // Return the entity + return target; + } + +} diff --git a/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SilentContainerChest.java b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SilentContainerChest.java new file mode 100644 index 0000000..09a4424 --- /dev/null +++ b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SilentContainerChest.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2011-2014 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 + * . + */ + +package com.lishid.openinv.internal.v1_12_R1; + +import net.minecraft.server.v1_12_R1.ContainerChest; +import net.minecraft.server.v1_12_R1.EntityHuman; +import net.minecraft.server.v1_12_R1.IInventory; +import net.minecraft.server.v1_12_R1.ItemStack; +import net.minecraft.server.v1_12_R1.PlayerInventory; + +public class SilentContainerChest extends ContainerChest { + + public SilentContainerChest(final PlayerInventory playerInventory, final IInventory iInventory, + final EntityHuman entityHuman) { + super(playerInventory, iInventory, entityHuman); + // Send close signal + iInventory.closeContainer(entityHuman); + } + + @Override + public void b(final EntityHuman entityHuman) { + // Don't send close signal twice, might screw up + PlayerInventory playerinventory = entityHuman.inventory; + + if (playerinventory.getCarried() != ItemStack.a) { + ItemStack carried = playerinventory.getCarried(); + playerinventory.setCarried(ItemStack.a); + entityHuman.drop(carried, false); + } + } + +} diff --git a/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SilentContainerShulkerBox.java b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SilentContainerShulkerBox.java new file mode 100644 index 0000000..bc94298 --- /dev/null +++ b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SilentContainerShulkerBox.java @@ -0,0 +1,57 @@ +package com.lishid.openinv.internal.v1_12_R1; + +import java.lang.reflect.Field; + +import net.minecraft.server.v1_12_R1.ContainerShulkerBox; +import net.minecraft.server.v1_12_R1.EntityHuman; +import net.minecraft.server.v1_12_R1.IInventory; +import net.minecraft.server.v1_12_R1.ItemStack; +import net.minecraft.server.v1_12_R1.PlayerInventory; +import net.minecraft.server.v1_12_R1.TileEntityShulkerBox; + +public class SilentContainerShulkerBox extends ContainerShulkerBox { + + private static Field fieldShulkerActionData; + + private static Field exposeOpenStatus() throws NoSuchFieldException, SecurityException { + if (SilentContainerShulkerBox.fieldShulkerActionData == null) { + SilentContainerShulkerBox.fieldShulkerActionData = TileEntityShulkerBox.class + .getDeclaredField("h"); + SilentContainerShulkerBox.fieldShulkerActionData.setAccessible(true); + } + return SilentContainerShulkerBox.fieldShulkerActionData; + } + + public static Integer getOpenValue(final TileEntityShulkerBox tileShulkerBox) { + try { + return (Integer) SilentContainerShulkerBox.exposeOpenStatus().get(tileShulkerBox); + } catch (Exception e) { + e.printStackTrace(); + return 0; + } + } + + public static void setOpenValue(final TileEntityShulkerBox tileShulkerBox, final Object value) { + try { + SilentContainerShulkerBox.exposeOpenStatus().set(tileShulkerBox, value); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public SilentContainerShulkerBox(final PlayerInventory playerInventory, + final IInventory iInventory, final EntityHuman entityHuman) { + super(playerInventory, iInventory, entityHuman); + } + + @Override + public void b(final EntityHuman entityHuman) { + PlayerInventory playerinventory = entityHuman.inventory; + + if (!playerinventory.getCarried().isEmpty()) { + entityHuman.drop(playerinventory.getCarried(), false); + playerinventory.setCarried(ItemStack.a); + } + } + +} diff --git a/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SpecialEnderChest.java b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SpecialEnderChest.java new file mode 100644 index 0000000..e052616 --- /dev/null +++ b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SpecialEnderChest.java @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2011-2014 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 + * . + */ + +package com.lishid.openinv.internal.v1_12_R1; + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.util.List; + +import com.lishid.openinv.internal.ISpecialEnderChest; + +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; + +import net.minecraft.server.v1_12_R1.EntityPlayer; +import net.minecraft.server.v1_12_R1.IInventory; +import net.minecraft.server.v1_12_R1.InventoryEnderChest; +import net.minecraft.server.v1_12_R1.InventorySubcontainer; +import net.minecraft.server.v1_12_R1.ItemStack; + +import org.bukkit.craftbukkit.v1_12_R1.inventory.CraftInventory; + +public class SpecialEnderChest extends InventorySubcontainer + implements IInventory, ISpecialEnderChest { + + private final InventoryEnderChest enderChest; + private final CraftInventory inventory = new CraftInventory(this); + private boolean playerOnline = false; + + public SpecialEnderChest(final Player player, final Boolean online) { + super(PlayerDataManager.getHandle(player).getEnderChest().getName(), + PlayerDataManager.getHandle(player).getEnderChest().hasCustomName(), + PlayerDataManager.getHandle(player).getEnderChest().getSize()); + EntityPlayer nmsPlayer = PlayerDataManager.getHandle(player); + this.enderChest = nmsPlayer.getEnderChest(); + this.bukkitOwner = nmsPlayer.getBukkitEntity(); + this.setItemLists(this, this.enderChest.getContents()); + } + + @Override + public Inventory getBukkitInventory() { + return this.inventory; + } + + @Override + public boolean isInUse() { + return !this.getViewers().isEmpty(); + } + + private void setItemLists(final InventorySubcontainer subcontainer, + final List list) { + try { + // Prepare to remove final modifier + Field modifiers = Field.class.getDeclaredField("modifiers"); + modifiers.setAccessible(true); + // Access and replace main inventory array + Field field = InventorySubcontainer.class.getField("items"); + modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL); + field.set(subcontainer, list); + } catch (NoSuchFieldException e) { + e.printStackTrace(); + } catch (SecurityException e) { + e.printStackTrace(); + } catch (IllegalArgumentException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + + @Override + public void setPlayerOffline() { + this.playerOnline = false; + } + + @Override + public void setPlayerOnline(final Player player) { + if (!this.playerOnline) { + try { + EntityPlayer nmsPlayer = PlayerDataManager.getHandle(player); + this.bukkitOwner = nmsPlayer.getBukkitEntity(); + this.setItemLists(nmsPlayer.getEnderChest(), this.items); + } catch (Exception e) {} + this.playerOnline = true; + } + } + + @Override + public void update() { + super.update(); + this.enderChest.update(); + } + +} diff --git a/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SpecialPlayerInventory.java b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SpecialPlayerInventory.java new file mode 100644 index 0000000..4774092 --- /dev/null +++ b/internal/v1_12_R1/src/main/java/com/lishid/openinv/internal/v1_12_R1/SpecialPlayerInventory.java @@ -0,0 +1,255 @@ +/* + * Copyright (C) 2011-2014 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 + * . + */ + +package com.lishid.openinv.internal.v1_12_R1; + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.util.Arrays; + +import com.lishid.openinv.internal.ISpecialPlayerInventory; + +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; + +import net.minecraft.server.v1_12_R1.ContainerUtil; +import net.minecraft.server.v1_12_R1.EntityHuman; +import net.minecraft.server.v1_12_R1.ItemStack; +import net.minecraft.server.v1_12_R1.NonNullList; +import net.minecraft.server.v1_12_R1.PlayerInventory; + +import org.bukkit.craftbukkit.v1_12_R1.inventory.CraftInventory; + +public class SpecialPlayerInventory extends PlayerInventory implements ISpecialPlayerInventory { + + private final CraftInventory inventory = new CraftInventory(this); + private boolean playerOnline = false; + + public SpecialPlayerInventory(final Player bukkitPlayer, final Boolean online) { + super(PlayerDataManager.getHandle(bukkitPlayer)); + this.playerOnline = online; + this.setItemArrays(this, this.player.inventory.items, this.player.inventory.armor, + this.player.inventory.extraSlots); + } + + @Override + public boolean a(final EntityHuman entityhuman) { + return true; + } + + @Override + public Inventory getBukkitInventory() { + return this.inventory; + } + + @Override + public ItemStack getItem(int i) { + NonNullList 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.a; + } + + return list.get(i); + } + + @Override + public String getName() { + if (this.player.getName().length() > 16) { + return this.player.getName().substring(0, 16); + } + return this.player.getName(); + } + + 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 super.getSize() + 4; + } + + @Override + public boolean isInUse() { + return !this.getViewers().isEmpty(); + } + + @Override + public void setItem(int i, final ItemStack itemstack) { + NonNullList 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; + } + + if (list != null) { + list.set(i, itemstack); + } + } + + private void setItemArrays(final PlayerInventory inventory, final NonNullList items, + final NonNullList armor, final NonNullList extraSlots) { + try { + // Prepare to remove final modifier + Field modifiers = Field.class.getDeclaredField("modifiers"); + modifiers.setAccessible(true); + + // Access and replace main inventory array + Field field = PlayerInventory.class.getField("items"); + modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL); + field.set(inventory, items); + + // Access and replace armor inventory array + field = PlayerInventory.class.getField("armor"); + modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL); + field.set(inventory, armor); + + // Access and replace offhand inventory array + field = PlayerInventory.class.getField("extraSlots"); + modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL); + field.set(inventory, extraSlots); + + // Access and replace array containing all inventory arrays + field = PlayerInventory.class.getDeclaredField("g"); + field.setAccessible(true); + modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL); + field.set(inventory, Arrays.asList(new NonNullList[] { items, armor, extraSlots })); + } catch (NoSuchFieldException e) { + // Unable to set final fields to item arrays, we're screwed. Noisily fail. + e.printStackTrace(); + } catch (IllegalArgumentException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + + @Override + public void setPlayerOffline() { + this.playerOnline = false; + } + + @Override + public void setPlayerOnline(final Player player) { + if (!this.playerOnline) { + this.player = PlayerDataManager.getHandle(player); + ; + this.setItemArrays(this.player.inventory, this.items, this.armor, this.extraSlots); + this.playerOnline = true; + } + } + + @Override + public ItemStack splitStack(int i, final int j) { + NonNullList 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.a; + } + + return list == null || list.get(i).isEmpty() ? ItemStack.a : ContainerUtil.a(list, i, j); + } + + @Override + public ItemStack splitWithoutUpdate(int i) { + NonNullList 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.a; + } + + if (list != null && !list.get(i).isEmpty()) { + ItemStack itemstack = list.get(i); + + list.set(i, ItemStack.a); + return itemstack; + } + + return ItemStack.a; + } + +}