Removed item wand functionality

Anyone who can use it has to be able to run the command anyway. If they can run the command, they can use tab completion to automatically fill in anyone online's name. There's no need to keep around a bunch of deprecated code for a function I sincerely doubt anyone actually uses.

.gitignore

@@ -1,9 +0,0 @@
-/.settings
-/.gitignore
-/.project
-/.classpath
-/.idea
-/target
-/bin
-/lib
-/out

.settings/org.eclipse.ltk.core.refactoring.prefs

@@ -0,0 +1,3 @@
+#Wed Jun 01 17:38:54 EDT 2011
+eclipse.preferences.version=1
+org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false

pom.xml

@@ -1,62 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>com.lishid</groupId>
-    <artifactId>openinv</artifactId>
-    <packaging>jar</packaging>
-    <version>2.3.1</version>
-    <name>OpenInv</name>
-    <url>http://dev.bukkit.org/bukkit-plugins/openinv/</url>
-
-    <properties>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-    <repositories>
-        <repository>
-            <id>bukkit-repo</id>
-            <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
-        </repository>
-    </repositories>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.bukkit</groupId>
-            <artifactId>bukkit</artifactId>
-            <version>1.8.7-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.bukkit</groupId>
-            <artifactId>craftbukkit</artifactId>
-            <version>1.8.7-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <defaultGoal>clean install</defaultGoal>
-        <sourceDirectory>src/main/java</sourceDirectory>
-        <resources>
-            <resource>
-                <directory>src/main/resources</directory>
-                <filtering>true</filtering>
-                <excludes>
-                    <exclude>**/*.java</exclude>
-                </excludes>
-            </resource>
-        </resources>
-
-        <plugins>
-            <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>2.3.2</version>
-                <configuration>
-                    <source>1.6</source>
-                    <target>1.6</target>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>

src/com/lishid/openinv/OpenInv.java

@@ -0,0 +1,201 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv;
+
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+import org.bukkit.ChatColor;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.Permissible;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.lishid.openinv.commands.AnyChestPluginCommand;
+import com.lishid.openinv.commands.OpenEnderPluginCommand;
+import com.lishid.openinv.commands.OpenInvPluginCommand;
+import com.lishid.openinv.commands.SearchInvPluginCommand;
+import com.lishid.openinv.commands.SilentChestPluginCommand;
+import com.lishid.openinv.internal.IAnySilentChest;
+import com.lishid.openinv.internal.IInventoryAccess;
+import com.lishid.openinv.internal.IPlayerDataManager;
+import com.lishid.openinv.internal.ISpecialEnderChest;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
+import com.lishid.openinv.internal.InternalAccessor;
+
+/**
+ * Open other player's inventory
+ * 
+ * @author lishid
+ */
+public class OpenInv extends JavaPlugin {
+    public static final Logger logger = Logger.getLogger("Minecraft.OpenInv");
+
+    public static HashMap<String, ISpecialPlayerInventory> inventories = new HashMap<String, ISpecialPlayerInventory>();
+    public static HashMap<String, ISpecialEnderChest> enderChests = new HashMap<String, ISpecialEnderChest>();
+
+    public static OpenInv mainPlugin;
+
+    public static IPlayerDataManager playerLoader;
+    public static IInventoryAccess inventoryAccess;
+    public static IAnySilentChest anySilentChest;
+
+    @Override
+    public void onEnable() {
+        // Get plugin manager
+        PluginManager pm = getServer().getPluginManager();
+
+        // Version check
+        boolean success = InternalAccessor.Initialize(this.getServer());
+
+        if (!success) {
+            OpenInv.log("Your version of CraftBukkit is not supported.");
+            OpenInv.log("Please look for an updated version of OpenInv.");
+            pm.disablePlugin(this);
+            return;
+        }
+
+        playerLoader = InternalAccessor.Instance.newPlayerDataManager();
+        inventoryAccess = InternalAccessor.Instance.newInventoryAccess();
+        anySilentChest = InternalAccessor.Instance.newAnySilentChest();
+
+        mainPlugin = this;
+        FileConfiguration config = getConfig();
+        config.set("NotifySilentChest", config.getBoolean("NotifySilentChest", true));
+        config.set("NotifyAnyChest", config.getBoolean("NotifyAnyChest", true));
+        config.addDefault("NotifySilentChest", true);
+        config.addDefault("NotifyAnyChest", true);
+        config.options().copyDefaults(true);
+        saveConfig();
+
+        pm.registerEvents(new OpenInvPlayerListener(), this);
+        pm.registerEvents(new OpenInvInventoryListener(), this);
+
+        getCommand("openinv").setExecutor(new OpenInvPluginCommand(this));
+        getCommand("searchinv").setExecutor(new SearchInvPluginCommand());
+        getCommand("silentchest").setExecutor(new SilentChestPluginCommand(this));
+        getCommand("anychest").setExecutor(new AnyChestPluginCommand(this));
+        getCommand("openender").setExecutor(new OpenEnderPluginCommand(this));
+
+    }
+
+    public static boolean NotifySilentChest() {
+        return mainPlugin.getConfig().getBoolean("NotifySilentChest", true);
+    }
+
+    public static boolean NotifyAnyChest() {
+        return mainPlugin.getConfig().getBoolean("NotifyAnyChest", true);
+    }
+
+    public static boolean GetCheckForUpdates() {
+        return mainPlugin.getConfig().getBoolean("CheckForUpdates", true);
+    }
+
+    public static boolean GetPlayerItemOpenInvStatus(String name) {
+        return mainPlugin.getConfig().getBoolean("ItemOpenInv." + name.toLowerCase() + ".toggle", false);
+    }
+
+    public static void SetPlayerItemOpenInvStatus(String name, boolean status) {
+        mainPlugin.getConfig().set("ItemOpenInv." + name.toLowerCase() + ".toggle", status);
+        mainPlugin.saveConfig();
+    }
+
+    public static boolean GetPlayerSilentChestStatus(String name) {
+        return mainPlugin.getConfig().getBoolean("SilentChest." + name.toLowerCase() + ".toggle", false);
+    }
+
+    public static void SetPlayerSilentChestStatus(String name, boolean status) {
+        mainPlugin.getConfig().set("SilentChest." + name.toLowerCase() + ".toggle", status);
+        mainPlugin.saveConfig();
+    }
+
+    public static boolean GetPlayerAnyChestStatus(String name) {
+        return mainPlugin.getConfig().getBoolean("AnyChest." + name.toLowerCase() + ".toggle", true);
+    }
+
+    public static void SetPlayerAnyChestStatus(String name, boolean status) {
+        mainPlugin.getConfig().set("AnyChest." + name.toLowerCase() + ".toggle", status);
+        mainPlugin.saveConfig();
+    }
+
+    public static int GetItemOpenInvItem() {
+        if (mainPlugin.getConfig().get("ItemOpenInvItemID") == null) {
+            SaveToConfig("ItemOpenInvItemID", 280);
+        }
+        return mainPlugin.getConfig().getInt("ItemOpenInvItemID", 280);
+    }
+
+    public static Object GetFromConfig(String data, Object defaultValue) {
+        Object val = mainPlugin.getConfig().get(data);
+        if (val == null) {
+            mainPlugin.getConfig().set(data, defaultValue);
+            return defaultValue;
+        }
+        else {
+            return val;
+        }
+    }
+
+    public static void SaveToConfig(String data, Object value) {
+        mainPlugin.getConfig().set(data, value);
+        mainPlugin.saveConfig();
+    }
+
+    /**
+     * Log an information
+     */
+    public static void log(String text) {
+        logger.info("[OpenInv] " + text);
+    }
+
+    /**
+     * Log an error
+     */
+    public static void log(Throwable e) {
+        logger.severe("[OpenInv] " + e.toString());
+        e.printStackTrace();
+    }
+
+    public static void ShowHelp(Player player) {
+        player.sendMessage(ChatColor.GREEN + "/openinv <Player> - Open a player's inventory");
+        player.sendMessage(ChatColor.GREEN + "   (aliases: oi, inv, open)");
+        player.sendMessage(ChatColor.GREEN + "/openender <Player> - Open a player's enderchest");
+        player.sendMessage(ChatColor.GREEN + "   (aliases: oe, enderchest)");
+        player.sendMessage(ChatColor.GREEN + "/toggleopeninv - Toggle item openinv function");
+        player.sendMessage(ChatColor.GREEN + "   (aliases: toi, toggleoi, toggleinv)");
+        player.sendMessage(ChatColor.GREEN + "/searchinv <Item> [MinAmount] - ");
+        player.sendMessage(ChatColor.GREEN + "   Search and list players having a specific item.");
+        player.sendMessage(ChatColor.GREEN + "   (aliases: si, search)");
+        player.sendMessage(ChatColor.GREEN + "/anychest - Toggle anychest function");
+        player.sendMessage(ChatColor.GREEN + "   (aliases: ac)");
+        player.sendMessage(ChatColor.GREEN + "/silentchest - Toggle silent chest function");
+        player.sendMessage(ChatColor.GREEN + "   (aliases: sc, silent)");
+    }
+
+    public static boolean hasPermission(Permissible player, String permission) {
+        String[] parts = permission.split("\\.");
+        String perm = "";
+        for (int i = 0; i < parts.length; i++) {
+            if (player.hasPermission(perm + "*")) {
+                return true;
+            }
+            perm += parts[i] + ".";
+        }
+        return player.hasPermission(permission);
+    }
+}

src/com/lishid/openinv/OpenInvInventoryListener.java

@@ -1,37 +1,43 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.listeners;
-
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.inventory.Inventory;
-
-import com.lishid.openinv.OpenInv;
-
-public class OpenInvInventoryListener implements Listener {
-    @EventHandler
-    public void onInventoryClick(InventoryClickEvent event) {
-        Inventory inventory = event.getInventory();
-        HumanEntity player = event.getWhoClicked();
-
-        if (!OpenInv.getInventoryAccess().check(inventory, player)) {
-            event.setCancelled(true);
-        }
-    }
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+
+public class OpenInvInventoryListener implements Listener {
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void onInventoryClick(InventoryClickEvent event) {
+        // If this is the top inventory
+        // if (event.getView().convertSlot(event.getRawSlot()) == event.getRawSlot())
+        // {
+        if (!OpenInv.inventoryAccess.check(event.getInventory(), event.getWhoClicked())) {
+            event.setCancelled(true);
+        }
+        // }
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void onInventoryDrag(InventoryDragEvent event) {
+        if (!OpenInv.inventoryAccess.check(event.getInventory(), event.getWhoClicked())) {
+            event.setCancelled(true);
+        }
+    }
 }

src/com/lishid/openinv/OpenInvPlayerListener.java

@@ -0,0 +1,125 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv;
+
+import org.bukkit.ChatColor;
+import org.bukkit.block.Chest;
+import org.bukkit.block.Sign;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event.Result;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import com.lishid.openinv.internal.ISpecialEnderChest;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
+
+public class OpenInvPlayerListener implements Listener {
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        ISpecialPlayerInventory inventory = OpenInv.inventories.get(event.getPlayer().getName().toLowerCase());
+
+        if (inventory != null) {
+            inventory.PlayerGoOnline(event.getPlayer());
+        }
+
+        ISpecialEnderChest chest = OpenInv.enderChests.get(event.getPlayer().getName().toLowerCase());
+
+        if (chest != null) {
+            chest.PlayerGoOnline(event.getPlayer());
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        ISpecialPlayerInventory inventory = OpenInv.inventories.get(event.getPlayer().getName().toLowerCase());
+        if (inventory != null) {
+            inventory.PlayerGoOffline();
+        }
+        ISpecialEnderChest chest = OpenInv.enderChests.get(event.getPlayer().getName().toLowerCase());
+        if (chest != null) {
+            chest.PlayerGoOffline();
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+
+        if (event.getPlayer().isSneaking()) {
+            return;
+        }
+
+        if (event.getAction() == Action.RIGHT_CLICK_BLOCK && event.useInteractedBlock() == Result.DENY) {
+            return;
+        }
+
+        if (event.getAction() == Action.RIGHT_CLICK_BLOCK && event.getClickedBlock().getType() == org.bukkit.Material.ENDER_CHEST) {
+            if (OpenInv.hasPermission(player, Permissions.PERM_SILENT) && OpenInv.GetPlayerSilentChestStatus(player.getName())) {
+                event.setCancelled(true);
+                player.openInventory(player.getEnderChest());
+            }
+        }
+
+        if (event.getAction() == Action.RIGHT_CLICK_BLOCK && event.getClickedBlock().getState() instanceof Chest) {
+            boolean silentchest = false;
+            boolean anychest = false;
+            int x = event.getClickedBlock().getX();
+            int y = event.getClickedBlock().getY();
+            int z = event.getClickedBlock().getZ();
+
+            if (OpenInv.hasPermission(player, Permissions.PERM_SILENT) && OpenInv.GetPlayerSilentChestStatus(player.getName())) {
+                silentchest = true;
+            }
+
+            if (OpenInv.hasPermission(player, Permissions.PERM_ANYCHEST) && OpenInv.GetPlayerAnyChestStatus(player.getName())) {
+                try {
+                    anychest = OpenInv.anySilentChest.IsAnyChestNeeded(player, x, y, z);
+                }
+                catch (Exception e) {
+                    player.sendMessage(ChatColor.RED + "Error while executing openinv. Unsupported CraftBukkit.");
+                    e.printStackTrace();
+                }
+            }
+
+            // If the anychest or silentchest is active
+            if (anychest || silentchest) {
+                if (!OpenInv.anySilentChest.ActivateChest(player, anychest, silentchest, x, y, z)) {
+                    event.setCancelled(true);
+                }
+            }
+        }
+
+        if (event.getAction() == Action.RIGHT_CLICK_BLOCK && event.getClickedBlock().getState() instanceof Sign) {
+            try {
+                Sign sign = ((Sign) event.getClickedBlock().getState());
+                if (OpenInv.hasPermission(player, Permissions.PERM_OPENINV) && sign.getLine(0).equalsIgnoreCase("[openinv]")) {
+                    String text = sign.getLine(1).trim() + sign.getLine(2).trim() + sign.getLine(3).trim();
+                    player.performCommand("openinv " + text);
+                }
+            }
+            catch (Exception ex) {
+                player.sendMessage("Internal Error.");
+                ex.printStackTrace();
+            }
+        }
+    }
+}

src/com/lishid/openinv/commands/AnyChestPluginCommand.java

@@ -0,0 +1,53 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.lishid.openinv.OpenInv;
+
+public class AnyChestPluginCommand implements CommandExecutor {
+    public AnyChestPluginCommand(OpenInv plugin) {
+
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ChatColor.RED + "You can't use this from the console.");
+            return true;
+        }
+
+        if (args.length > 0) {
+            if (args[0].equalsIgnoreCase("check")) {
+                if (OpenInv.GetPlayerAnyChestStatus(sender.getName()))
+                    sender.sendMessage("AnyChest is ON.");
+                else
+                    sender.sendMessage("AnyChest is OFF.");
+            }
+        }
+
+        OpenInv.SetPlayerAnyChestStatus(sender.getName(), !OpenInv.GetPlayerAnyChestStatus(sender.getName()));
+        sender.sendMessage("AnyChest is now " + (OpenInv.GetPlayerAnyChestStatus(sender.getName()) ? "On" : "Off") + ".");
+
+        return true;
+    }
+}

src/com/lishid/openinv/commands/OpenEnderPluginCommand.java

@@ -0,0 +1,141 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.commands;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.Permissions;
+import com.lishid.openinv.internal.ISpecialEnderChest;
+import com.lishid.openinv.internal.InternalAccessor;
+
+public class OpenEnderPluginCommand implements CommandExecutor {
+    private final OpenInv plugin;
+    public static HashMap<Player, String> openEnderHistory = new HashMap<Player, String>();
+
+    public OpenEnderPluginCommand(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ChatColor.RED + "You can't use this from the console.");
+            return true;
+        }
+
+        if (args.length > 0 && args[0].equalsIgnoreCase("?")) {
+            OpenInv.ShowHelp((Player) sender);
+            return true;
+        }
+
+        final Player player = (Player) sender;
+
+        // History management
+        String history = openEnderHistory.get(player);
+
+        if (history == null || history == "") {
+            history = player.getName();
+            openEnderHistory.put(player, history);
+        }
+
+        final String name;
+
+        // Read from history if target is not named
+        if (args.length < 1) {
+            name = history;
+        }
+        else {
+            name = args[0];
+        }
+
+        final UUID senderID = player.getUniqueId();
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                List<Player> matches = Bukkit.matchPlayer(name);
+                if (!matches.isEmpty()) {
+                    openInventory(player, matches.get(0).getUniqueId());
+                    return;
+                }
+                final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(name);
+                if (Bukkit.getPlayer(senderID) == null) {
+                    return;
+                }
+                if (offlinePlayer == null || !offlinePlayer.hasPlayedBefore()) {
+                    player.sendMessage(ChatColor.RED + "Player not found!");
+                    return;
+                }
+                new BukkitRunnable() {
+                    @Override
+                    public void run() {
+                        if (Bukkit.getPlayer(senderID) == null) {
+                            return;
+                        }
+                        openInventory(player, offlinePlayer.getUniqueId());
+                    }
+                }.runTask(plugin);
+            }
+        }.runTaskAsynchronously(plugin);
+
+        return true;
+    }
+
+    private void openInventory(Player player, UUID uuid) {
+
+        Player target = this.plugin.getServer().getPlayer(uuid);
+
+        if (target == null) {
+            // Try loading the player's data
+            target = OpenInv.playerLoader.loadPlayer(uuid);
+
+            if (target == null) {
+                player.sendMessage(ChatColor.RED + "Player not found!");
+                return;
+            }
+        }
+
+
+        if (target != player && !OpenInv.hasPermission(player, Permissions.PERM_ENDERCHEST_ALL)) {
+            player.sendMessage(ChatColor.RED + "You do not have permission to access other player's enderchest");
+            return;
+        }
+
+        // Record the target
+        openEnderHistory.put(player, target.getName());
+
+        // Create the inventory
+        ISpecialEnderChest chest = OpenInv.enderChests.get(target.getName().toLowerCase());
+        if (chest == null) {
+            chest = InternalAccessor.Instance.newSpecialEnderChest(target, !target.isOnline());
+        }
+
+        // Open the inventory
+        player.openInventory(chest.getBukkitInventory());
+    }
+}

src/com/lishid/openinv/commands/OpenInvPluginCommand.java

@@ -0,0 +1,153 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.commands;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.Permissions;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
+import com.lishid.openinv.internal.InternalAccessor;
+
+public class OpenInvPluginCommand implements CommandExecutor {
+    private final OpenInv plugin;
+    public static HashMap<Player, String> openInvHistory = new HashMap<Player, String>();
+
+    public OpenInvPluginCommand(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ChatColor.RED + "You can't use this from the console.");
+            return true;
+        }
+
+        if (args.length > 0 && args[0].equalsIgnoreCase("?")) {
+            OpenInv.ShowHelp((Player) sender);
+            return true;
+        }
+
+        final Player player = (Player) sender;
+
+        // History management
+        String history = openInvHistory.get(player);
+
+        if (history == null || history == "") {
+            history = player.getName();
+            openInvHistory.put(player, history);
+        }
+
+        final String name;
+
+        // Read from history if target is not named
+        if (args.length < 1) {
+            name = history;
+        }
+        else {
+            name = args[0];
+        }
+
+        final UUID senderID = player.getUniqueId();
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                List<Player> matches = Bukkit.matchPlayer(name);
+                if (!matches.isEmpty()) {
+                    openInventory(player, matches.get(0).getUniqueId());
+                    return;
+                }
+                final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(name);
+                if (Bukkit.getPlayer(senderID) == null) {
+                    return;
+                }
+                if (offlinePlayer == null || !offlinePlayer.hasPlayedBefore()) {
+                    player.sendMessage(ChatColor.RED + "Player not found!");
+                    return;
+                }
+                new BukkitRunnable() {
+                    @Override
+                    public void run() {
+                        if (Bukkit.getPlayer(senderID) == null) {
+                            return;
+                        }
+                        openInventory(player, offlinePlayer.getUniqueId());
+                    }
+                }.runTask(plugin);
+            }
+        }.runTaskAsynchronously(plugin);
+
+        return true;
+    }
+
+    private void openInventory(Player player, UUID uuid) {
+
+        Player target = this.plugin.getServer().getPlayer(uuid);
+
+        if (target == null) {
+            // Try loading the player's data
+            target = OpenInv.playerLoader.loadPlayer(uuid);
+
+            if (target == null) {
+                player.sendMessage(ChatColor.RED + "Player not found!");
+                return;
+            }
+        }
+
+        // Permissions checks
+        if (!OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE) && OpenInv.hasPermission(target, Permissions.PERM_EXEMPT)) {
+            player.sendMessage(ChatColor.RED + target.getDisplayName() + "'s inventory is protected!");
+            return;
+        }
+
+        // Crosswork check
+        if ((!OpenInv.hasPermission(player, Permissions.PERM_CROSSWORLD) && !OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE)) && target.getWorld() != player.getWorld()) {
+            player.sendMessage(ChatColor.RED + target.getDisplayName() + " is not in your world!");
+            return;
+        }
+
+        // Self-open check
+        if (!OpenInv.hasPermission(player, Permissions.PERM_OPENSELF) && target.equals(player)) {
+            player.sendMessage(ChatColor.RED + "You're not allowed to openinv yourself.");
+            return;
+        }
+
+        // Record the target
+        openInvHistory.put(player, target.getName());
+
+        // Create the inventory
+        ISpecialPlayerInventory inv = OpenInv.inventories.get(target.getName().toLowerCase());
+        if (inv == null) {
+            inv = InternalAccessor.Instance.newSpecialPlayerInventory(target, !target.isOnline());
+        }
+
+        // Open the inventory
+        player.openInventory(inv.getBukkitInventory());
+    }
+}

src/com/lishid/openinv/commands/SearchInvPluginCommand.java

@@ -0,0 +1,68 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class SearchInvPluginCommand implements CommandExecutor {
+    public SearchInvPluginCommand() {
+
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        String PlayerList = "";
+
+        Material material = null;
+        int count = 1;
+
+        if (args.length >= 1) {
+            String[] gData = null;
+            gData = args[0].split(":");
+            material = Material.matchMaterial(gData[0]);
+        }
+        if (args.length >= 2) {
+            try {
+                count = Integer.parseInt(args[1]);
+            }
+            catch (NumberFormatException ex) {
+                sender.sendMessage(ChatColor.RED + "'" + args[1] + "' is not a number!");
+                return false;
+            }
+        }
+
+        if (material == null) {
+            sender.sendMessage(ChatColor.RED + "Unknown item");
+            return false;
+        }
+
+        for (Player templayer : Bukkit.getServer().getOnlinePlayers()) {
+            if (templayer.getInventory().contains(material, count)) {
+                PlayerList += templayer.getName() + "  ";
+            }
+        }
+
+        sender.sendMessage("Players with the item " + material.toString() + ":  " + PlayerList);
+        return true;
+    }
+}

src/com/lishid/openinv/commands/SilentChestPluginCommand.java

@@ -0,0 +1,53 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.lishid.openinv.OpenInv;
+
+public class SilentChestPluginCommand implements CommandExecutor {
+    public SilentChestPluginCommand(OpenInv plugin) {
+
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(ChatColor.RED + "You can't use this from the console.");
+            return true;
+        }
+
+        if (args.length > 0) {
+            if (args[0].equalsIgnoreCase("check")) {
+                if (OpenInv.GetPlayerSilentChestStatus(sender.getName()))
+                    sender.sendMessage("SilentChest is ON.");
+                else
+                    sender.sendMessage("SilentChest is OFF.");
+            }
+        }
+
+        OpenInv.SetPlayerSilentChestStatus(sender.getName(), !OpenInv.GetPlayerSilentChestStatus(sender.getName()));
+        sender.sendMessage("SilentChest is now " + (OpenInv.GetPlayerSilentChestStatus(sender.getName()) ? "On" : "Off") + ".");
+
+        return true;
+    }
+}

src/com/lishid/openinv/internal/IAnySilentChest.java

@@ -0,0 +1,25 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal;
+
+import org.bukkit.entity.Player;
+
+public interface IAnySilentChest {
+    public boolean IsAnyChestNeeded(Player p, int x, int y, int z);
+
+    public boolean ActivateChest(Player p, boolean anychest, boolean silentchest, int x, int y, int z);
+}

src/com/lishid/openinv/internal/IInventoryAccess.java

@@ -0,0 +1,24 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal;
+
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.Inventory;
+
+public interface IInventoryAccess {
+    public boolean check(Inventory inventory, HumanEntity player);
+}

src/com/lishid/openinv/internal/IPlayerDataManager.java

@@ -0,0 +1,26 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal;
+
+import java.util.UUID;
+
+import org.bukkit.entity.Player;
+
+public interface IPlayerDataManager {
+    public Player loadPlayer(String name);
+    public Player loadPlayer(UUID uuid);
+}

src/com/lishid/openinv/internal/ISpecialEnderChest.java

@@ -0,0 +1,31 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+
+public interface ISpecialEnderChest {
+    public Inventory getBukkitInventory();
+
+    public void InventoryRemovalCheck();
+
+    public void PlayerGoOnline(Player p);
+
+    public void PlayerGoOffline();
+
+}

src/com/lishid/openinv/internal/ISpecialPlayerInventory.java

@@ -0,0 +1,30 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+
+public interface ISpecialPlayerInventory {
+    public Inventory getBukkitInventory();
+
+    public void InventoryRemovalCheck();
+
+    public void PlayerGoOnline(Player p);
+
+    public void PlayerGoOffline();
+}

src/com/lishid/openinv/internal/InternalAccessor.java

@@ -0,0 +1,105 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal;
+
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+import com.lishid.openinv.OpenInv;
+
+public class InternalAccessor {
+    public static InternalAccessor Instance;
+    private String version;
+
+    /*
+     * Returns false if version not supported
+     */
+    public static boolean Initialize(Server server) {
+        Instance = new InternalAccessor();
+        String packageName = server.getClass().getPackage().getName();
+        Instance.version = packageName.substring(packageName.lastIndexOf('.') + 1);
+
+        try {
+            Class.forName("com.lishid.openinv.internal." + Instance.version + ".AnySilentChest");
+            return true;
+        }
+        catch (Exception e) {
+            return false;
+        }
+    }
+
+    public void PrintError() {
+        OpenInv.log("OpenInv encountered an error with the CraftBukkit version \"" + Instance.version + "\". Please look for an updated version of OpenInv.");
+    }
+
+    public IPlayerDataManager newPlayerDataManager() {
+        return (IPlayerDataManager) createObject(IPlayerDataManager.class, "PlayerDataManager");
+    }
+
+    public IInventoryAccess newInventoryAccess() {
+        return (IInventoryAccess) createObject(IInventoryAccess.class, "InventoryAccess");
+    }
+
+    public IAnySilentChest newAnySilentChest() {
+        return (IAnySilentChest) createObject(IAnySilentChest.class, "AnySilentChest");
+    }
+
+    public ISpecialPlayerInventory newSpecialPlayerInventory(Player player, boolean offline) {
+        try {
+            Class<?> internalClass = Class.forName("com.lishid.openinv.internal." + version + ".SpecialPlayerInventory");
+            if (ISpecialPlayerInventory.class.isAssignableFrom(internalClass)) {
+                return (ISpecialPlayerInventory) internalClass.getConstructor(Player.class, Boolean.class).newInstance(player, offline);
+            }
+        }
+        catch (Exception e) {
+            PrintError();
+            OpenInv.log(e);
+        }
+
+        return null;
+    }
+
+    public ISpecialEnderChest newSpecialEnderChest(Player player, boolean offline) {
+        try {
+            Class<?> internalClass = Class.forName("com.lishid.openinv.internal." + version + ".SpecialEnderChest");
+            if (ISpecialEnderChest.class.isAssignableFrom(internalClass)) {
+                return (ISpecialEnderChest) internalClass.getConstructor(Player.class, Boolean.class).newInstance(player, offline);
+            }
+        }
+        catch (Exception e) {
+            PrintError();
+            OpenInv.log(e);
+        }
+
+        return null;
+    }
+
+    private Object createObject(Class<? extends Object> assignableClass, String className) {
+        try {
+            Class<?> internalClass = Class.forName("com.lishid.openinv.internal." + version + "." + className);
+            if (assignableClass.isAssignableFrom(internalClass)) {
+                return internalClass.getConstructor().newInstance();
+            }
+        }
+        catch (Exception e) {
+            PrintError();
+            OpenInv.log(e);
+        }
+
+        return null;
+    }
+}

src/com/lishid/openinv/internal/v1_9_R1/AnySilentChest.java

@@ -0,0 +1,152 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_9_R1;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IAnySilentChest;
+
+//Volatile
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+
+import net.minecraft.server.v1_9_R1.AxisAlignedBB;
+import net.minecraft.server.v1_9_R1.Block;
+import net.minecraft.server.v1_9_R1.BlockPosition;
+import net.minecraft.server.v1_9_R1.Entity;
+import net.minecraft.server.v1_9_R1.EntityOcelot;
+import net.minecraft.server.v1_9_R1.EntityPlayer;
+import net.minecraft.server.v1_9_R1.IInventory;
+import net.minecraft.server.v1_9_R1.ITileInventory;
+import net.minecraft.server.v1_9_R1.InventoryLargeChest;
+import net.minecraft.server.v1_9_R1.PacketPlayOutOpenWindow;
+import net.minecraft.server.v1_9_R1.TileEntityChest;
+import net.minecraft.server.v1_9_R1.World;
+
+public class AnySilentChest implements IAnySilentChest {
+    @Override
+    public boolean IsAnyChestNeeded(Player p, int x, int y, int z) {
+        // FOR REFERENCE, LOOK AT net.minecraft.server.BlockChest
+        EntityPlayer player = ((CraftPlayer) p).getHandle();
+        World world = player.world;
+        // If block or ocelot on top
+        if (world.getType(new BlockPosition(x, y + 1, z)).l() || hasOcelotOnTop(world, x, y, z))
+            return true;
+
+        int id = Block.getId(world.getType(new BlockPosition(x, y, z)).getBlock());
+
+        // If block next to chest is chest and has a block or ocelot on top
+        if (isBlockedChest(world, id, x - 1, y, z))
+            return true;
+        if (isBlockedChest(world, id, x + 1, y, z))
+            return true;
+        if (isBlockedChest(world, id, x, y, z - 1))
+            return true;
+        if (isBlockedChest(world, id, x, y, z + 1))
+            return true;
+
+        return false;
+    }
+
+    private boolean isBlockedChest(World world, int id, int x, int y, int z) {
+        BlockPosition position = new BlockPosition(x, y, z);
+        if (Block.getId(world.getType(position).getBlock()) != id) {
+            return false;
+        }
+
+        if (world.getType(position).l()) {
+            return true;
+        }
+
+        return hasOcelotOnTop(world, x, y, z);
+    }
+
+    private boolean hasOcelotOnTop(World world, int x, int y, int z) {
+        for (Entity localEntity : world.a(EntityOcelot.class,
+                new AxisAlignedBB(x, y + 1, z, x + 1, y + 2, z + 1))) {
+            EntityOcelot localEntityOcelot = (EntityOcelot) localEntity;
+            if (localEntityOcelot.isSitting()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean ActivateChest(Player p, boolean anychest, boolean silentchest, int x, int y, int z) {
+        EntityPlayer player = ((CraftPlayer) p).getHandle();
+        World world = player.world;
+        Object chest = world.getTileEntity(new BlockPosition(x, y, z));
+        if (chest == null)
+            return true;
+
+        int id = Block.getId(world.getType(new BlockPosition(x, y, z)).getBlock());
+
+        if (!anychest) {
+            if (world.getType(new BlockPosition(x, y + 1, z)).l())
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x - 1, y, z)).getBlock()) == id) && (world.getType(new BlockPosition(x - 1, y + 1, z)).l()))
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x + 1, y, z)).getBlock()) == id) && (world.getType(new BlockPosition(x + 1, y + 1, z)).l()))
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x, y, z - 1)).getBlock()) == id) && (world.getType(new BlockPosition(x, y + 1, z - 1)).l()))
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x, y, z + 1)).getBlock()) == id) && (world.getType(new BlockPosition(x, y + 1, z + 1)).l()))
+                return true;
+        }
+
+        if (Block.getId(world.getType(new BlockPosition(x - 1, y, z)).getBlock()) == id)
+            chest = new InventoryLargeChest("Large chest", (TileEntityChest) world.getTileEntity(new BlockPosition(x - 1, y, z)), (ITileInventory) chest);
+        if (Block.getId(world.getType(new BlockPosition(x + 1, y, z)).getBlock()) == id)
+            chest = new InventoryLargeChest("Large chest", (ITileInventory) chest, (TileEntityChest) world.getTileEntity(new BlockPosition(x + 1, y, z)));
+        if (Block.getId(world.getType(new BlockPosition(x, y, z - 1)).getBlock()) == id)
+            chest = new InventoryLargeChest("Large chest", (TileEntityChest) world.getTileEntity(new BlockPosition(x, y, z - 1)), (ITileInventory) chest);
+        if (Block.getId(world.getType(new BlockPosition(x, y, z + 1)).getBlock()) == id)
+            chest = new InventoryLargeChest("Large chest", (ITileInventory) chest, (TileEntityChest) world.getTileEntity(new BlockPosition(x, y, z + 1)));
+
+        boolean returnValue = true;
+        if (!silentchest) {
+            player.openContainer((IInventory) chest);
+        }
+        else {
+            try {
+                SilentContainerChest silentContainerChest = new SilentContainerChest(player.inventory, ((IInventory) chest), player);
+                int windowId = player.nextContainerCounter();
+                player.playerConnection.sendPacket(new PacketPlayOutOpenWindow(windowId, "minecraft:chest", ((IInventory) chest).getScoreboardDisplayName(), ((IInventory) chest).getSize()));
+                player.activeContainer = silentContainerChest;
+                player.activeContainer.windowId = windowId;
+                player.activeContainer.addSlotListener(player);
+                if (OpenInv.NotifySilentChest()) {
+                    p.sendMessage("You are opening a chest silently.");
+                }
+                returnValue = false;
+            }
+            catch (Exception e) {
+                e.printStackTrace();
+                p.sendMessage(ChatColor.RED + "Error while sending silent chest.");
+            }
+        }
+
+        if (anychest && OpenInv.NotifyAnyChest()) {
+            p.sendMessage("You are opening a blocked chest.");
+        }
+
+        return returnValue;
+    }
+}

src/com/lishid/openinv/internal/v1_9_R1/InventoryAccess.java

@@ -14,7 +14,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.lishid.openinv.internal;
+package com.lishid.openinv.internal.v1_9_R1;
 
 import java.lang.reflect.Field;
 
@@ -23,13 +23,15 @@ import org.bukkit.inventory.Inventory;
 
 import com.lishid.openinv.OpenInv;
 import com.lishid.openinv.Permissions;
+import com.lishid.openinv.internal.IInventoryAccess;
 
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
+//Volatile
+import org.bukkit.craftbukkit.v1_9_R1.inventory.CraftInventory;
 
-import org.bukkit.craftbukkit.v1_8_R3.inventory.*;
+import net.minecraft.server.v1_9_R1.IInventory;
 
-public class InventoryAccess {
+public class InventoryAccess implements IInventoryAccess {
+    @Override
     public boolean check(Inventory inventory, HumanEntity player) {
         IInventory inv = grabInventory(inventory);
         
@@ -53,7 +55,7 @@ public class InventoryAccess {
             return ((CraftInventory) inventory).getInventory();
         }
         
-        // Use reflection to find the inventory
+        //Use reflection to find the iiventory
         Class<? extends Inventory> clazz = inventory.getClass();
         IInventory result = null;
         for(Field f : clazz.getDeclaredFields()) {

src/com/lishid/openinv/internal/v1_9_R1/PlayerDataManager.java

@@ -0,0 +1,132 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_9_R1;
+
+import java.io.File;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IPlayerDataManager;
+import com.mojang.authlib.GameProfile;
+
+//Volatile
+import org.bukkit.craftbukkit.v1_9_R1.CraftServer;
+
+import net.minecraft.server.v1_9_R1.EntityPlayer;
+import net.minecraft.server.v1_9_R1.MinecraftServer;
+import net.minecraft.server.v1_9_R1.PlayerInteractManager;
+
+public class PlayerDataManager implements IPlayerDataManager {
+    @Override
+    public Player loadPlayer(String name) {
+        try {
+            UUID uuid = matchUser(name);
+            if (uuid == null) {
+                return null;
+            }
+
+            // Default player folder
+            File playerfolder = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "playerdata");
+            if (!playerfolder.exists()) {
+                return null;
+            }
+
+            OfflinePlayer player = Bukkit.getOfflinePlayer(uuid);
+            if (player == null) {
+                return null;
+            }
+            GameProfile profile = new GameProfile(uuid, player.getName());
+            MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
+            // Create an entity to load the player data
+            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;
+            }
+        }
+        catch (Exception e) {
+            OpenInv.log(e);
+        }
+
+        return null;
+    }
+
+    private static UUID matchUser(String search) {
+        UUID found = null;
+
+        String lowerSearch = search.toLowerCase();
+        int delta = 2147483647;
+
+        OfflinePlayer[] offlinePlayers = Bukkit.getOfflinePlayers();
+        for (OfflinePlayer player : offlinePlayers) {
+            String name = player.getName();
+           
+            if (name == null){
+                continue;
+            }
+            if (name.equalsIgnoreCase(search)){
+                return player.getUniqueId();
+            }
+            if (name.toLowerCase().startsWith(lowerSearch)) {
+                int curDelta = name.length() - lowerSearch.length();
+                if (curDelta < delta) {
+                    found = player.getUniqueId();
+                    delta = curDelta;
+                }
+                if (curDelta == 0) {
+                    break;
+                }
+            }
+        }
+
+        return found;
+    }
+
+    /* (non-Javadoc)
+     * @see com.lishid.openinv.internal.IPlayerDataManager#loadPlayer(java.util.UUID)
+     */
+    @Override
+    public Player loadPlayer(UUID uuid) {
+        OfflinePlayer player = Bukkit.getOfflinePlayer(uuid);
+        if (player == null || !player.hasPlayedBefore()) {
+            return null;
+        }
+        GameProfile profile = new GameProfile(uuid, player.getName());
+        MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
+        // Create an entity to load the player data
+        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;
+        }
+        return null;
+    }
+}

src/com/lishid/openinv/internal/v1_9_R1/SilentContainerChest.java

@@ -14,23 +14,25 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.lishid.openinv.internal;
+package com.lishid.openinv.internal.v1_9_R1;
 
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
+//Volatile
+import net.minecraft.server.v1_9_R1.ContainerChest;
+import net.minecraft.server.v1_9_R1.EntityHuman;
+import net.minecraft.server.v1_9_R1.IInventory;
 
 public class SilentContainerChest extends ContainerChest {
     public IInventory inv;
 
-    public SilentContainerChest(IInventory i1, IInventory i2, EntityHuman human) {
-        super(i1, i2, human);
+    public SilentContainerChest(IInventory i1, IInventory i2, EntityHuman e1) {
+        super(i1, i2, e1);
         inv = i2;
-        // Close signal
-        inv.closeContainer(human);
+        // close signal
+        inv.closeContainer(e1);
     }
 
     @Override
     public void b(EntityHuman paramEntityHuman) {
         // Don't send close signal twice, might screw up
     }
-}
+}

src/com/lishid/openinv/internal/v1_9_R1/SpecialEnderChest.java

@@ -0,0 +1,145 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_9_R1;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.ISpecialEnderChest;
+
+//Volatile
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.craftbukkit.v1_9_R1.inventory.CraftInventory;
+
+import net.minecraft.server.v1_9_R1.EntityHuman;
+import net.minecraft.server.v1_9_R1.IInventory;
+import net.minecraft.server.v1_9_R1.InventoryEnderChest;
+import net.minecraft.server.v1_9_R1.InventorySubcontainer;
+import net.minecraft.server.v1_9_R1.ItemStack;
+
+public class SpecialEnderChest extends InventorySubcontainer implements IInventory, ISpecialEnderChest {
+    public List<HumanEntity> transaction = new ArrayList<HumanEntity>();
+    public boolean playerOnline = false;
+    private final CraftPlayer owner;
+    private final InventoryEnderChest enderChest;
+    private int maxStack = MAX_STACK;
+    private final CraftInventory inventory = new CraftInventory(this);
+
+    public SpecialEnderChest(Player p, Boolean online) {
+        super(((CraftPlayer) p).getHandle().getEnderChest().getName(), ((CraftPlayer) p).getHandle().getEnderChest().hasCustomName(), ((CraftPlayer) p).getHandle().getEnderChest().getSize());
+        CraftPlayer player = (CraftPlayer) p;
+        this.enderChest = player.getHandle().getEnderChest();
+        this.owner = player;
+        this.items = enderChest.getContents();
+        OpenInv.enderChests.put(owner.getName().toLowerCase(), this);
+    }
+
+    @Override
+    public Inventory getBukkitInventory() {
+        return inventory;
+    }
+
+    @Override
+    public void InventoryRemovalCheck() {
+        owner.saveData();
+        if (transaction.isEmpty() && !playerOnline) {
+            OpenInv.enderChests.remove(owner.getName().toLowerCase());
+        }
+    }
+
+    @Override
+    public void PlayerGoOnline(Player p) {
+        if (!playerOnline) {
+            try {
+                InventoryEnderChest playerEnderChest = ((CraftPlayer) p).getHandle().getEnderChest();
+                Field field = playerEnderChest.getClass().getField("items");
+                field.setAccessible(true);
+                field.set(playerEnderChest, this.items);
+            }
+            catch (Exception e) {}
+            p.saveData();
+            playerOnline = true;
+        }
+    }
+
+    @Override
+    public void PlayerGoOffline() {
+        playerOnline = false;
+    }
+
+    @Override
+    public ItemStack[] getContents() {
+        return this.items;
+    }
+
+    @Override
+    public void onOpen(CraftHumanEntity who) {
+        transaction.add(who);
+    }
+
+    @Override
+    public void onClose(CraftHumanEntity who) {
+        transaction.remove(who);
+        this.InventoryRemovalCheck();
+    }
+
+    @Override
+    public List<HumanEntity> getViewers() {
+        return transaction;
+    }
+
+    @Override
+    public InventoryHolder getOwner() {
+        return this.owner;
+    }
+
+    @Override
+    public void setMaxStackSize(int size) {
+        maxStack = size;
+    }
+
+    @Override
+    public int getMaxStackSize() {
+        return maxStack;
+    }
+
+    @Override
+    public boolean a(EntityHuman entityhuman) {
+        return true;
+    }
+
+    public void startOpen() {
+
+    }
+
+    public void f() {
+
+    }
+
+    @Override
+    public void update() {
+        enderChest.update();
+    }
+}

src/com/lishid/openinv/internal/v1_9_R1/SpecialPlayerInventory.java

@@ -14,70 +14,93 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.lishid.openinv.internal;
+package com.lishid.openinv.internal.v1_9_R1;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
 
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
 
 import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
 
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
+//Volatile
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftHumanEntity;
+import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
+import org.bukkit.craftbukkit.v1_9_R1.inventory.CraftInventory;
 
-import org.bukkit.craftbukkit.v1_8_R3.entity.*;
-import org.bukkit.craftbukkit.v1_8_R3.inventory.*;
+import net.minecraft.server.v1_9_R1.EntityHuman;
+import net.minecraft.server.v1_9_R1.ItemStack;
+import net.minecraft.server.v1_9_R1.PlayerInventory;
 
-public class SpecialPlayerInventory extends PlayerInventory {
-    private final CraftInventory inventory = new CraftInventory(this);
+public class SpecialPlayerInventory extends PlayerInventory implements ISpecialPlayerInventory {
+    CraftPlayer owner;
+    public boolean playerOnline = false;
     private final ItemStack[] extra = new ItemStack[5];
-    private final CraftPlayer owner;
-    private boolean playerOnline;
+    private final CraftInventory inventory = new CraftInventory(this);
 
-    public SpecialPlayerInventory(Player p, boolean online) {
+    public SpecialPlayerInventory(Player p, Boolean online) {
         super(((CraftPlayer) p).getHandle());
-        this.owner = (CraftPlayer) p;
-        this.items = player.inventory.items;
-        this.armor = player.inventory.armor;
+        this.owner = ((CraftPlayer) p);
         this.playerOnline = online;
-        OpenInv.inventories.put(owner.getUniqueId(), this);
+        setItemArrays(this, player.inventory.items, player.inventory.armor, player.inventory.extraSlots);
+        OpenInv.inventories.put(owner.getName().toLowerCase(), this);
     }
 
+    private void setItemArrays(PlayerInventory inventory, ItemStack[] items, ItemStack[] armor,
+            ItemStack[] extraSlots) {
+        try {
+            Field field = inventory.getClass().getField("items");
+            Field modifiers = Field.class.getDeclaredField("modifiers");
+            modifiers.setAccessible(true);
+            modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+            field.set(inventory, items);
+            field = inventory.getClass().getField("armor");
+            modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+            field.set(inventory, armor);
+            field = inventory.getClass().getField("extraSlots");
+            modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException
+                | IllegalAccessException e) {
+            // Unable to set final fields to item arrays, we're screwed. Noisily fail.
+            e.printStackTrace();
+        }
+    }
+
+    @Override
     public Inventory getBukkitInventory() {
         return inventory;
     }
 
-    private void saveOnExit() {
+    @Override
+    public void InventoryRemovalCheck() {
+        owner.saveData();
         if (transaction.isEmpty() && !playerOnline) {
-            owner.saveData();
-            OpenInv.inventories.remove(owner.getUniqueId());
+            OpenInv.inventories.remove(owner.getName().toLowerCase());
         }
     }
 
-    private void linkInventory(PlayerInventory inventory) {
-        inventory.items = this.items;
-        inventory.armor = this.armor;
-    }
-
-    public void playerOnline(Player player) {
+    @Override
+    public void PlayerGoOnline(Player player) {
         if (!playerOnline) {
             CraftPlayer p = (CraftPlayer) player;
-            linkInventory(p.getHandle().inventory);
+            setItemArrays(p.getHandle().inventory, items, armor, extraSlots);
             p.saveData();
             playerOnline = true;
         }
     }
 
-    public void playerOffline() {
+    @Override
+    public void PlayerGoOffline() {
         playerOnline = false;
-        owner.loadData();
-        linkInventory(owner.getHandle().inventory);
-        saveOnExit();
+        this.InventoryRemovalCheck();
     }
 
     @Override
     public void onClose(CraftHumanEntity who) {
         super.onClose(who);
-        this.saveOnExit();
+        this.InventoryRemovalCheck();
     }
 
     @Override
@@ -100,17 +123,26 @@ public class SpecialPlayerInventory extends PlayerInventory {
         if (i >= is.length) {
             i -= is.length;
             is = this.armor;
-        } else {
+        }
+        else {
             i = getReversedItemSlotNum(i);
         }
 
         if (i >= is.length) {
             i -= is.length;
-            is = this.extra;
-        } else if (is == this.armor) {
+            is = this.extraSlots;
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
+        if (i >= is.length) {
+            i -= is.length;
+            is = this.extra;
+        }
+
+        // extraSlots is, for now, just an array with length 1. No need for special handling.
+
         return is[i];
     }
 
@@ -121,17 +153,24 @@ public class SpecialPlayerInventory extends PlayerInventory {
         if (i >= is.length) {
             i -= is.length;
             is = this.armor;
-        } else {
+        }
+        else {
             i = getReversedItemSlotNum(i);
         }
 
         if (i >= is.length) {
             i -= is.length;
-            is = this.extra;
-        } else if (is == this.armor) {
+            is = this.extraSlots;
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
+        if (i >= is.length) {
+            i -= is.length;
+            is = this.extra;
+        }
+
         if (is[i] != null) {
             ItemStack itemstack;
 
@@ -139,15 +178,17 @@ public class SpecialPlayerInventory extends PlayerInventory {
                 itemstack = is[i];
                 is[i] = null;
                 return itemstack;
-            } else {
-                itemstack = is[i].a(j);
+            }
+            else {
+                itemstack = is[i].cloneAndSubtract(j);
                 if (is[i].count == 0) {
                     is[i] = null;
                 }
 
                 return itemstack;
             }
-        } else {
+        }
+        else {
             return null;
         }
     }
@@ -159,52 +200,67 @@ public class SpecialPlayerInventory extends PlayerInventory {
         if (i >= is.length) {
             i -= is.length;
             is = this.armor;
-        } else {
+        }
+        else {
             i = getReversedItemSlotNum(i);
         }
 
         if (i >= is.length) {
             i -= is.length;
-            is = this.extra;
-        } else if (is == this.armor) {
+            is = this.extraSlots;
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
+        if (i >= is.length) {
+            i -= is.length;
+            is = this.extra;
+        }
+
         if (is[i] != null) {
             ItemStack itemstack = is[i];
 
             is[i] = null;
             return itemstack;
-        } else {
+        }
+        else {
             return null;
         }
     }
 
     @Override
-    public void setItem(int i, ItemStack itemStack) {
+    public void setItem(int i, ItemStack itemstack) {
         ItemStack[] is = this.items;
 
         if (i >= is.length) {
             i -= is.length;
             is = this.armor;
-        } else {
+        }
+        else {
             i = getReversedItemSlotNum(i);
         }
 
         if (i >= is.length) {
             i -= is.length;
-            is = this.extra;
-        } else if (is == this.armor) {
+            is = this.extraSlots;
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
+        if (i >= is.length) {
+            i -= is.length;
+            is = this.extra;
+        }
+
         // Effects
         if (is == this.extra) {
-            owner.getHandle().drop(itemStack, true);
-            itemStack = null;
+            owner.getHandle().drop(itemstack, true);
+            itemstack = null;
         }
 
-        is[i] = itemStack;
+        is[i] = itemstack;
 
         owner.getHandle().defaultContainer.b();
     }
@@ -229,13 +285,11 @@ public class SpecialPlayerInventory extends PlayerInventory {
             return i;
     }
 
-    @Override
-    public boolean hasCustomName() {
-        return true;
-    }
-
     @Override
     public String getName() {
+        if (player.getName().length() > 16) {
+            return player.getName().substring(0, 16);
+        }
         return player.getName();
     }
 
@@ -243,10 +297,4 @@ public class SpecialPlayerInventory extends PlayerInventory {
     public boolean a(EntityHuman entityhuman) {
         return true;
     }
-
-    @Override
-    public void update() {
-        super.update();
-        player.inventory.update();
-    }
-}
+}

src/com/lishid/openinv/utils/ReflectionUtil.java

@@ -0,0 +1,510 @@
+package com.lishid.openinv.utils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bukkit.Bukkit;
+
+public final class ReflectionUtil {
+    private ReflectionUtil() {}
+
+    public static Class<?> getClass(String name, PackageType type) throws Exception {
+        return Class.forName(type + "." + name);
+    }
+
+    public static Class<?> getClass(String name, SubPackageType type) throws Exception {
+        return Class.forName(type + "." + name);
+    }
+
+    public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... parameterTypes) {
+        Class<?>[] p = DataType.convertToPrimitive(parameterTypes);
+        for (Constructor<?> c : clazz.getConstructors())
+            if (DataType.equalsArray(DataType.convertToPrimitive(c.getParameterTypes()), p))
+                return c;
+        return null;
+    }
+
+    public static Constructor<?> getConstructor(String className, PackageType type, Class<?>... parameterTypes) throws Exception {
+        return getConstructor(getClass(className, type), parameterTypes);
+    }
+
+    public static Constructor<?> getConstructor(String className, SubPackageType type, Class<?>... parameterTypes) throws Exception {
+        return getConstructor(getClass(className, type), parameterTypes);
+    }
+
+    public static Object newInstance(Class<?> clazz, Object... args) throws Exception {
+        return getConstructor(clazz, DataType.convertToPrimitive(args)).newInstance(args);
+    }
+
+    public static Object newInstance(String className, PackageType type, Object... args) throws Exception {
+        return newInstance(getClass(className, type), args);
+    }
+
+    public static Object newInstance(String className, SubPackageType type, Object... args) throws Exception {
+        return newInstance(getClass(className, type), args);
+    }
+
+    public static Method getMethod(Class<?> clazz, String name, Class<?>... parameterTypes) {
+        Class<?>[] p = DataType.convertToPrimitive(parameterTypes);
+        for (Method m : clazz.getMethods())
+            if (m.getName().equals(name) && DataType.equalsArray(DataType.convertToPrimitive(m.getParameterTypes()), p))
+                return m;
+        return null;
+    }
+
+    public static Method getMethod(String className, PackageType type, String name, Class<?>... parameterTypes) throws Exception {
+        return getMethod(getClass(className, type), name, parameterTypes);
+    }
+
+    public static Method getMethod(String className, SubPackageType type, String name, Class<?>... parameterTypes) throws Exception {
+        return getMethod(getClass(className, type), name, parameterTypes);
+    }
+
+    public static Object invokeMethod(String name, Object instance, Object... args) throws Exception {
+        return getMethod(instance.getClass(), name, DataType.convertToPrimitive(args)).invoke(instance, args);
+    }
+
+    public static Object invokeMethod(Class<?> clazz, String name, Object instance, Object... args) throws Exception {
+        return getMethod(clazz, name, DataType.convertToPrimitive(args)).invoke(instance, args);
+    }
+
+    public static Object invokeMethod(String className, PackageType type, String name, Object instance, Object... args) throws Exception {
+        return invokeMethod(getClass(className, type), name, instance, args);
+    }
+
+    public static Object invokeMethod(String className, SubPackageType type, String name, Object instance, Object... args) throws Exception {
+        return invokeMethod(getClass(className, type), name, instance, args);
+    }
+
+    public static Field getField(Class<?> clazz, String name) throws Exception {
+        Field f = clazz.getField(name);
+        f.setAccessible(true);
+        return f;
+    }
+
+    public static Field getField(String className, PackageType type, String name) throws Exception {
+        return getField(getClass(className, type), name);
+    }
+
+    public static Field getField(String className, SubPackageType type, String name) throws Exception {
+        return getField(getClass(className, type), name);
+    }
+
+    public static Field getDeclaredField(Class<?> clazz, String name) throws Exception {
+        Field f = clazz.getDeclaredField(name);
+        f.setAccessible(true);
+        return f;
+    }
+
+    public static Field getDeclaredField(String className, PackageType type, String name) throws Exception {
+        return getDeclaredField(getClass(className, type), name);
+    }
+
+    public static Field getDeclaredField(String className, SubPackageType type, String name) throws Exception {
+        return getDeclaredField(getClass(className, type), name);
+    }
+
+    public static Object getValue(Object instance, String fieldName) throws Exception {
+        return getField(instance.getClass(), fieldName).get(instance);
+    }
+
+    public static Object getValue(Class<?> clazz, Object instance, String fieldName) throws Exception {
+        return getField(clazz, fieldName).get(instance);
+    }
+
+    public static Object getValue(String className, PackageType type, Object instance, String fieldName) throws Exception {
+        return getValue(getClass(className, type), instance, fieldName);
+    }
+
+    public static Object getValue(String className, SubPackageType type, Object instance, String fieldName) throws Exception {
+        return getValue(getClass(className, type), instance, fieldName);
+    }
+
+    public static Object getDeclaredValue(Object instance, String fieldName) throws Exception {
+        return getDeclaredField(instance.getClass(), fieldName).get(instance);
+    }
+
+    public static Object getDeclaredValue(Class<?> clazz, Object instance, String fieldName) throws Exception {
+        return getDeclaredField(clazz, fieldName).get(instance);
+    }
+
+    public static Object getDeclaredValue(String className, PackageType type, Object instance, String fieldName) throws Exception {
+        return getDeclaredValue(getClass(className, type), instance, fieldName);
+    }
+
+    public static Object getDeclaredValue(String className, SubPackageType type, Object instance, String fieldName) throws Exception {
+        return getDeclaredValue(getClass(className, type), instance, fieldName);
+    }
+
+    public static void setValue(Object instance, String fieldName, Object fieldValue) throws Exception {
+        Field f = getField(instance.getClass(), fieldName);
+        f.set(instance, fieldValue);
+    }
+
+    public static void setValue(Object instance, FieldPair pair) throws Exception {
+        setValue(instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setValue(Class<?> clazz, Object instance, String fieldName, Object fieldValue) throws Exception {
+        Field f = getField(clazz, fieldName);
+        f.set(instance, fieldValue);
+    }
+
+    public static void setValue(Class<?> clazz, Object instance, FieldPair pair) throws Exception {
+        setValue(clazz, instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setValue(String className, PackageType type, Object instance, String fieldName, Object fieldValue) throws Exception {
+        setValue(getClass(className, type), instance, fieldName, fieldValue);
+    }
+
+    public static void setValue(String className, PackageType type, Object instance, FieldPair pair) throws Exception {
+        setValue(className, type, instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setValue(String className, SubPackageType type, Object instance, String fieldName, Object fieldValue) throws Exception {
+        setValue(getClass(className, type), instance, fieldName, fieldValue);
+    }
+
+    public static void setValue(String className, SubPackageType type, Object instance, FieldPair pair) throws Exception {
+        setValue(className, type, instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setValues(Object instance, FieldPair... pairs) throws Exception {
+        for (FieldPair pair : pairs)
+            setValue(instance, pair);
+    }
+
+    public static void setValues(Class<?> clazz, Object instance, FieldPair... pairs) throws Exception {
+        for (FieldPair pair : pairs)
+            setValue(clazz, instance, pair);
+    }
+
+    public static void setValues(String className, PackageType type, Object instance, FieldPair... pairs) throws Exception {
+        setValues(getClass(className, type), instance, pairs);
+    }
+
+    public static void setValues(String className, SubPackageType type, Object instance, FieldPair... pairs) throws Exception {
+        setValues(getClass(className, type), instance, pairs);
+    }
+
+    public static void setDeclaredValue(Object instance, String fieldName, Object fieldValue) throws Exception {
+        Field f = getDeclaredField(instance.getClass(), fieldName);
+        f.set(instance, fieldValue);
+    }
+
+    public static void setDeclaredValue(Object instance, FieldPair pair) throws Exception {
+        setDeclaredValue(instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setDeclaredValue(Class<?> clazz, Object instance, String fieldName, Object fieldValue) throws Exception {
+        Field f = getDeclaredField(clazz, fieldName);
+        f.set(instance, fieldValue);
+    }
+
+    public static void setDeclaredValue(Class<?> clazz, Object instance, FieldPair pair) throws Exception {
+        setDeclaredValue(clazz, instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setDeclaredValue(String className, PackageType type, Object instance, String fieldName, Object fieldValue) throws Exception {
+        setDeclaredValue(getClass(className, type), instance, fieldName, fieldValue);
+    }
+
+    public static void setDeclaredValue(String className, PackageType type, Object instance, FieldPair pair) throws Exception {
+        setDeclaredValue(className, type, instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setDeclaredValue(String className, SubPackageType type, Object instance, String fieldName, Object fieldValue) throws Exception {
+        setDeclaredValue(getClass(className, type), instance, fieldName, fieldValue);
+    }
+
+    public static void setDeclaredValue(String className, SubPackageType type, Object instance, FieldPair pair) throws Exception {
+        setDeclaredValue(className, type, instance, pair.getName(), pair.getValue());
+    }
+
+    public static void setDeclaredValues(Object instance, FieldPair... pairs) throws Exception {
+        for (FieldPair pair : pairs)
+            setDeclaredValue(instance, pair);
+    }
+
+    public static void setDeclaredValues(Class<?> clazz, Object instance, FieldPair... pairs) throws Exception {
+        for (FieldPair pair : pairs)
+            setDeclaredValue(clazz, instance, pair);
+    }
+
+    public static void setDeclaredValues(String className, PackageType type, Object instance, FieldPair... pairs) throws Exception {
+        setDeclaredValues(getClass(className, type), instance, pairs);
+    }
+
+    public static void setDeclaredValues(String className, SubPackageType type, Object instance, FieldPair... pairs) throws Exception {
+        setDeclaredValues(getClass(className, type), instance, pairs);
+    }
+
+    public enum DataType {
+        BYTE(byte.class, Byte.class),
+        SHORT(short.class, Short.class),
+        INTEGER(int.class, Integer.class),
+        LONG(long.class, Long.class),
+        CHARACTER(char.class, Character.class),
+        FLOAT(float.class, Float.class),
+        DOUBLE(double.class, Double.class),
+        BOOLEAN(boolean.class, Boolean.class);
+
+        private static final Map<Class<?>, DataType> CLASS_MAP = new HashMap<Class<?>, DataType>();
+        private final Class<?> primitive;
+        private final Class<?> reference;
+
+        static {
+            for (DataType t : values()) {
+                CLASS_MAP.put(t.primitive, t);
+                CLASS_MAP.put(t.reference, t);
+            }
+        }
+
+        private DataType(Class<?> primitive, Class<?> reference) {
+            this.primitive = primitive;
+            this.reference = reference;
+        }
+
+        public Class<?> getPrimitive() {
+            return this.primitive;
+        }
+
+        public Class<?> getReference() {
+            return this.reference;
+        }
+
+        public static DataType fromClass(Class<?> c) {
+            return CLASS_MAP.get(c);
+        }
+
+        public static Class<?> getPrimitive(Class<?> c) {
+            DataType t = fromClass(c);
+            return t == null ? c : t.getPrimitive();
+        }
+
+        public static Class<?> getReference(Class<?> c) {
+            DataType t = fromClass(c);
+            return t == null ? c : t.getReference();
+        }
+
+        public static Class<?>[] convertToPrimitive(Class<?>[] classes) {
+            int length = classes == null ? 0 : classes.length;
+            Class<?>[] types = new Class<?>[length];
+            for (int i = 0; i < length; i++)
+                types[i] = getPrimitive(classes[i]);
+            return types;
+        }
+
+        public static Class<?>[] convertToPrimitive(Object[] objects) {
+            int length = objects == null ? 0 : objects.length;
+            Class<?>[] types = new Class<?>[length];
+            for (int i = 0; i < length; i++)
+                types[i] = getPrimitive(objects[i].getClass());
+            return types;
+        }
+
+        public static boolean equalsArray(Class<?>[] a1, Class<?>[] a2) {
+            if (a1 == null || a2 == null || a1.length != a2.length)
+                return false;
+            for (int i = 0; i < a1.length; i++)
+                if (!a1[i].equals(a2[i]) && !a1[i].isAssignableFrom(a2[i]))
+                    return false;
+            return true;
+        }
+    }
+
+    public final class FieldPair {
+        private final String name;
+        private final Object value;
+
+        public FieldPair(String name, Object value) {
+            this.name = name;
+            this.value = value;
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        public Object getValue() {
+            return this.value;
+        }
+    }
+
+    public enum PackageType {
+        MINECRAFT_SERVER("net.minecraft.server." + Bukkit.getServer().getClass().getPackage().getName().substring(23)),
+        CRAFTBUKKIT(Bukkit.getServer().getClass().getPackage().getName());
+
+        private final String name;
+
+        private PackageType(String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+
+    public enum SubPackageType {
+        BLOCK,
+        CHUNKIO,
+        COMMAND,
+        CONVERSATIONS,
+        ENCHANTMENS,
+        ENTITY,
+        EVENT,
+        GENERATOR,
+        HELP,
+        INVENTORY,
+        MAP,
+        METADATA,
+        POTION,
+        PROJECTILES,
+        SCHEDULER,
+        SCOREBOARD,
+        UPDATER,
+        UTIL;
+
+        private final String name;
+
+        private SubPackageType() {
+            name = PackageType.CRAFTBUKKIT + "." + name().toLowerCase();
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+
+    public enum PacketType {
+        HANDSHAKING_IN_SET_PROTOCOL("PacketHandshakingInSetProtocol"),
+        LOGIN_IN_ENCRYPTION_BEGIN("PacketLoginInEncryptionBegin"),
+        LOGIN_IN_START("PacketLoginInStart"),
+        LOGIN_OUT_DISCONNECT("PacketLoginOutDisconnect"),
+        LOGIN_OUT_ENCRYPTION_BEGIN("PacketLoginOutEncryptionBegin"),
+        LOGIN_OUT_SUCCESS("PacketLoginOutSuccess"),
+        PLAY_IN_ABILITIES("PacketPlayInAbilities"),
+        PLAY_IN_ARM_ANIMATION("PacketPlayInArmAnimation"),
+        PLAY_IN_BLOCK_DIG("PacketPlayInBlockDig"),
+        PLAY_IN_BLOCK_PLACE("PacketPlayInBlockPlace"),
+        PLAY_IN_CHAT("PacketPlayInChat"),
+        PLAY_IN_CLIENT_COMMAND("PacketPlayInClientCommand"),
+        PLAY_IN_CLOSE_WINDOW("PacketPlayInCloseWindow"),
+        PLAY_IN_CUSTOM_PAYLOAD("PacketPlayInCustomPayload"),
+        PLAY_IN_ENCHANT_ITEM("PacketPlayInEnchantItem"),
+        PLAY_IN_ENTITY_ACTION("PacketPlayInEntityAction"),
+        PLAY_IN_FLYING("PacketPlayInFlying"),
+        PLAY_IN_HELD_ITEM_SLOT("PacketPlayInHeldItemSlot"),
+        PLAY_IN_KEEP_ALIVE("PacketPlayInKeepAlive"),
+        PLAY_IN_LOOK("PacketPlayInLook"),
+        PLAY_IN_POSITION("PacketPlayInPosition"),
+        PLAY_IN_POSITION_LOOK("PacketPlayInPositionLook"),
+        PLAY_IN_SET_CREATIVE_SLOT("PacketPlayInSetCreativeSlot "),
+        PLAY_IN_SETTINGS("PacketPlayInSettings"),
+        PLAY_IN_STEER_VEHICLE("PacketPlayInSteerVehicle"),
+        PLAY_IN_TAB_COMPLETE("PacketPlayInTabComplete"),
+        PLAY_IN_TRANSACTION("PacketPlayInTransaction"),
+        PLAY_IN_UPDATE_SIGN("PacketPlayInUpdateSign"),
+        PLAY_IN_USE_ENTITY("PacketPlayInUseEntity"),
+        PLAY_IN_WINDOW_CLICK("PacketPlayInWindowClick"),
+        PLAY_OUT_ABILITIES("PacketPlayOutAbilities"),
+        PLAY_OUT_ANIMATION("PacketPlayOutAnimation"),
+        PLAY_OUT_ATTACH_ENTITY("PacketPlayOutAttachEntity"),
+        PLAY_OUT_BED("PacketPlayOutBed"),
+        PLAY_OUT_BLOCK_ACTION("PacketPlayOutBlockAction"),
+        PLAY_OUT_BLOCK_BREAK_ANIMATION("PacketPlayOutBlockBreakAnimation"),
+        PLAY_OUT_BLOCK_CHANGE("PacketPlayOutBlockChange"),
+        PLAY_OUT_CHAT("PacketPlayOutChat"),
+        PLAY_OUT_CLOSE_WINDOW("PacketPlayOutCloseWindow"),
+        PLAY_OUT_COLLECT("PacketPlayOutCollect"),
+        PLAY_OUT_CRAFT_PROGRESS_BAR("PacketPlayOutCraftProgressBar"),
+        PLAY_OUT_CUSTOM_PAYLOAD("PacketPlayOutCustomPayload"),
+        PLAY_OUT_ENTITY("PacketPlayOutEntity"),
+        PLAY_OUT_ENTITY_DESTROY("PacketPlayOutEntityDestroy"),
+        PLAY_OUT_ENTITY_EFFECT("PacketPlayOutEntityEffect"),
+        PLAY_OUT_ENTITY_EQUIPMENT("PacketPlayOutEntityEquipment"),
+        PLAY_OUT_ENTITY_HEAD_ROTATION("PacketPlayOutEntityHeadRotation"),
+        PLAY_OUT_ENTITY_LOOK("PacketPlayOutEntityLook"),
+        PLAY_OUT_ENTITY_METADATA("PacketPlayOutEntityMetadata"),
+        PLAY_OUT_ENTITY_STATUS("PacketPlayOutEntityStatus"),
+        PLAY_OUT_ENTITY_TELEPORT("PacketPlayOutEntityTeleport"),
+        PLAY_OUT_ENTITY_VELOCITY("PacketPlayOutEntityVelocity"),
+        PLAY_OUT_EXPERIENCE("PacketPlayOutExperience"),
+        PLAY_OUT_EXPLOSION("PacketPlayOutExplosion"),
+        PLAY_OUT_GAME_STATE_CHANGE("PacketPlayOutGameStateChange"),
+        PLAY_OUT_HELD_ITEM_SLOT("PacketPlayOutHeldItemSlot"),
+        PLAY_OUT_KEEP_ALIVE("PacketPlayOutKeepAlive"),
+        PLAY_OUT_KICK_DISCONNECT("PacketPlayOutKickDisconnect"),
+        PLAY_OUT_LOGIN("PacketPlayOutLogin"),
+        PLAY_OUT_MAP("PacketPlayOutMap"),
+        PLAY_OUT_MAP_CHUNK("PacketPlayOutMapChunk"),
+        PLAY_OUT_MAP_CHUNK_BULK("PacketPlayOutMapChunkBulk"),
+        PLAY_OUT_MULTI_BLOCK_CHANGE("PacketPlayOutMultiBlockChange"),
+        PLAY_OUT_NAMED_ENTITY_SPAWN("PacketPlayOutNamedEntitySpawn"),
+        PLAY_OUT_NAMED_SOUND_EFFECT("PacketPlayOutNamedSoundEffect"),
+        PLAY_OUT_OPEN_SIGN_EDITOR("PacketPlayOutOpenSignEditor"),
+        PLAY_OUT_OPEN_WINDOW("PacketPlayOutOpenWindow"),
+        PLAY_OUT_PLAYER_INFO("PacketPlayOutPlayerInfo"),
+        PLAY_OUT_POSITION("PacketPlayOutPosition"),
+        PLAY_OUT_REL_ENTITY_MOVE("PacketPlayOutRelEntityMove"),
+        PLAY_OUT_REL_ENTITY_MOVE_LOOK("PacketPlayOutRelEntityMoveLook"),
+        PLAY_OUT_REMOVE_ENTITY_EFFECT("PacketPlayOutRemoveEntityEffect"),
+        PLAY_OUT_RESPAWN("PacketPlayOutRespawn"),
+        PLAY_OUT_SCOREBOARD_DISPLAY_OBJECTIVE("PacketPlayOutScoreboardDisplayObjective"),
+        PLAY_OUT_SCOREBOARD_OBJECTIVE("PacketPlayOutScoreboardObjective"),
+        PLAY_OUT_SCOREBOARD_SCORE("PacketPlayOutScoreboardScore"),
+        PLAY_OUT_SCOREBOARD_TEAM("PacketPlayOutScoreboardTeam"),
+        PLAY_OUT_SET_SLOT("PacketPlayOutSetSlot"),
+        PLAY_OUT_SPAWN_ENTITY("PacketPlayOutSpawnEntity"),
+        PLAY_OUT_SPAWN_ENTITY_EXPERIENCE_ORB("PacketPlayOutSpawnEntityExperienceOrb"),
+        PLAY_OUT_SPAWN_ENTITY_LIVING("PacketPlayOutSpawnEntityLiving"),
+        PLAY_OUT_SPAWN_ENTITY_PAINTING("PacketPlayOutSpawnEntityPainting"),
+        PLAY_OUT_SPAWN_ENTITY_WEATHER("PacketPlayOutSpawnEntityWeather"),
+        PLAY_OUT_SPAWN_POSITION("PacketPlayOutSpawnPosition"),
+        PLAY_OUT_STATISTIC("PacketPlayOutStatistic"),
+        PLAY_OUT_TAB_COMPLETE("PacketPlayOutTabComplete"),
+        PLAY_OUT_TILE_ENTITY_DATA("PacketPlayOutTileEntityData"),
+        PLAY_OUT_TRANSACTION("PacketPlayOutTransaction"),
+        PLAY_OUT_UPDATE_ATTRIBUTES("PacketPlayOutUpdateAttributes"),
+        PLAY_OUT_UPDATE_HEALTH("PacketPlayOutUpdateHealth"),
+        PLAY_OUT_UPDATE_SIGN("PacketPlayOutUpdateSign"),
+        PLAY_OUT_UPDATE_TIME("PacketPlayOutUpdateTime"),
+        PLAY_OUT_WINDOW_ITEMS("PacketPlayOutWindowItems"),
+        PLAY_OUT_WORLD_EVENT("PacketPlayOutWorldEvent"),
+        PLAY_OUT_WORLD_PARTICLES("PacketPlayOutWorldParticles"),
+        STATUS_IN_PING("PacketStatusInPing"),
+        STATUS_IN_START("PacketStatusInStart"),
+        STATUS_OUT_PONG("PacketStatusOutPong"),
+        STATUS_OUT_SERVER_INFO("PacketStatusOutServerInfo");
+
+        private final String name;
+        private Class<?> packet;
+
+        private PacketType(String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return this.getName();
+        }
+
+        public Class<?> getPacket() throws Exception {
+            return packet == null ? packet = ReflectionUtil.getClass(name, PackageType.MINECRAFT_SERVER) : packet;
+        }
+    }
+}

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

@@ -1,160 +0,0 @@
-package com.lishid.openinv;
-
-import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-import org.bukkit.Material;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.FileConfiguration;
-
-import com.lishid.openinv.utils.UUIDUtil;
-
-public class ConfigUpdater {
-    private final OpenInv plugin;
-
-    private static final int CONFIG_VERSION = 2;
-
-    public ConfigUpdater(OpenInv plugin) {
-        this.plugin = plugin;
-    }
-
-    private int getConfigVersion() {
-        return plugin.getConfig().getInt("config-version", 1);
-    }
-
-    private boolean isConfigOutdated() {
-        return getConfigVersion() < CONFIG_VERSION;
-    }
-
-    public void checkForUpdates() {
-        if (isConfigOutdated()) {
-            plugin.getLogger().info("[Config] Update found! Performing update...");
-            performUpdate();
-        }
-        else {
-            plugin.getLogger().info("[Config] Update not required.");
-        }
-    }
-
-    private void performUpdate() {
-        // Update according to the right version
-        switch (getConfigVersion()) {
-            case 1:
-                updateConfig1To2();
-                break;
-        }
-    }
-
-    private void updateConfig1To2() {
-        FileConfiguration config = plugin.getConfig();
-
-        // Backup the old config file
-        File configFile = new File(plugin.getDataFolder(), "config.yml");
-        File oldConfigFile = new File(plugin.getDataFolder(), "config_old.yml");
-
-        configFile.renameTo(oldConfigFile);
-
-        if (configFile.exists()) {
-            configFile.delete();
-        }
-
-        plugin.getLogger().info("[Config] Backup of old config.yml file created.");
-
-        // Get the old config settings
-        int itemOpenInvItemId = config.getInt("ItemOpenInvItemID", 280);
-        boolean notifySilentChest = config.getBoolean("NotifySilentChest", true);
-        boolean notifyAnyChest = config.getBoolean("NotifyAnyChest", true);
-
-        Map<UUID, Boolean> anyChestToggles = null;
-        Map<UUID, Boolean> itemOpenInvToggles = null;
-        Map<UUID, Boolean> silentChestToggles = null;
-
-        if (config.isSet("AnyChest")) {
-            anyChestToggles = updateToggles("AnyChest");
-        }
-
-        if (config.isSet("ItemOpenInv")) {
-            itemOpenInvToggles = updateToggles("ItemOpenInv");
-        }
-
-        if (config.isSet("SilentChest")) {
-            silentChestToggles = updateToggles("SilentChest");
-        }
-
-        // Clear the old config
-        for (String key : config.getKeys(false)) {
-            config.set(key, null);
-        }
-
-        // Set the new config options
-        plugin.saveDefaultConfig();
-        plugin.reloadConfig();
-
-        config = plugin.getConfig(); // Refresh the referenced plugin config
-
-        config.set("config-version", 2);
-        config.set("items.open-inv", getMaterialById(itemOpenInvItemId).toString());
-        config.set("notify.any-chest", notifyAnyChest);
-        config.set("notify.silent-chest", notifySilentChest);
-
-        if (anyChestToggles != null && !anyChestToggles.isEmpty()) {
-            for (Map.Entry<UUID, Boolean> entry : anyChestToggles.entrySet()) {
-                config.set("toggles.any-chest." + entry.getKey(), entry.getValue());
-            }
-        }
-
-        if (itemOpenInvToggles != null && !itemOpenInvToggles.isEmpty()) {
-            for (Map.Entry<UUID, Boolean> entry : itemOpenInvToggles.entrySet()) {
-                config.set("toggles.items.open-inv." + entry.getKey(), entry.getValue());
-            }
-        }
-
-        if (silentChestToggles != null && !silentChestToggles.isEmpty()) {
-            for (Map.Entry<UUID, Boolean> entry : silentChestToggles.entrySet()) {
-                config.set("toggles.silent-chest." + entry.getKey(), entry.getValue());
-            }
-        }
-
-        // Save the new config
-        plugin.saveConfig();
-        plugin.getLogger().info("[Config] Update complete.");
-    }
-
-    private Map<UUID, Boolean> updateToggles(String sectionName) {
-        Map<UUID, Boolean> toggles = new HashMap<UUID, Boolean>();
-
-        ConfigurationSection section = plugin.getConfig().getConfigurationSection(sectionName);
-        Set<String> keys = section.getKeys(false);
-        if (keys == null || keys.isEmpty()) {
-            return null;
-        }
-
-        int total = keys.size();
-        int converted = 0;
-
-        for (String playerName : keys) {
-            UUID uuid = UUIDUtil.getUUIDOf(playerName);
-            if (uuid != null) {
-                boolean toggled = section.getBoolean(playerName + ".toggle", false);
-                toggles.put(uuid, toggled);
-                converted++;
-            }
-        }
-
-        plugin.getLogger().info("[Config] Converted (" + converted + "/" + total + ") " + sectionName + " toggle player usernames to UUIDs.");
-
-        return toggles;
-    }
-
-    @SuppressWarnings("deprecation")
-    private Material getMaterialById(int id) {
-        Material material = Material.getMaterial(id);
-        if (material == null) {
-            material = Material.STICK;
-        }
-        return material;
-    }
-}

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

@@ -1,226 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.permissions.Permissible;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import com.lishid.openinv.commands.AnyChestCommand;
-import com.lishid.openinv.commands.OpenEnderCommand;
-import com.lishid.openinv.commands.OpenInvCommand;
-import com.lishid.openinv.commands.SearchEnderCommand;
-import com.lishid.openinv.commands.SearchInvCommand;
-import com.lishid.openinv.commands.SilentChestCommand;
-import com.lishid.openinv.commands.ToggleOpenInvCommand;
-import com.lishid.openinv.internal.AnySilentChest;
-import com.lishid.openinv.internal.InventoryAccess;
-import com.lishid.openinv.internal.PlayerDataManager;
-import com.lishid.openinv.internal.SpecialEnderChest;
-import com.lishid.openinv.internal.SpecialPlayerInventory;
-import com.lishid.openinv.listeners.OpenInvEntityListener;
-import com.lishid.openinv.listeners.OpenInvInventoryListener;
-import com.lishid.openinv.listeners.OpenInvPlayerListener;
-
-/**
- * Open other player's inventory
- *
- * @author lishid
- */
-public class OpenInv extends JavaPlugin {
-    public static final Map<UUID, SpecialPlayerInventory> inventories = new HashMap<UUID, SpecialPlayerInventory>();
-    public static final Map<UUID, SpecialEnderChest> enderChests = new HashMap<UUID, SpecialEnderChest>();
-
-    public static OpenInv mainPlugin;
-
-    private static PlayerDataManager playerLoader;
-    private static InventoryAccess inventoryAccess;
-    private static AnySilentChest anySilentChest;
-
-    @Override
-    public void onEnable() {
-        // Plugin
-        mainPlugin = this;
-
-        // Config Updater
-        ConfigUpdater configUpdater = new ConfigUpdater(this);
-        configUpdater.checkForUpdates();
-
-        // Initialize
-        playerLoader = new PlayerDataManager();
-        inventoryAccess = new InventoryAccess();
-        anySilentChest = new AnySilentChest();
-
-        // Save the default config.yml if it doesn't already exist
-        saveDefaultConfig();
-
-        // Register the plugin's events & commands
-        registerEvents();
-        registerCommands();
-    }
-
-    private void registerEvents() {
-        PluginManager pm = getServer().getPluginManager();
-
-        pm.registerEvents(new OpenInvPlayerListener(), this);
-        pm.registerEvents(new OpenInvEntityListener(), this);
-        pm.registerEvents(new OpenInvInventoryListener(), this);
-    }
-
-    private void registerCommands() {
-        getCommand("openinv").setExecutor(new OpenInvCommand(this));
-        getCommand("openender").setExecutor(new OpenEnderCommand(this));
-        getCommand("searchinv").setExecutor(new SearchInvCommand());
-        getCommand("searchender").setExecutor(new SearchEnderCommand());
-        getCommand("toggleopeninv").setExecutor(new ToggleOpenInvCommand());
-        getCommand("anychest").setExecutor(new AnyChestCommand());
-        getCommand("silentchest").setExecutor(new SilentChestCommand());
-    }
-
-    public static PlayerDataManager getPlayerLoader() {
-        return playerLoader;
-    }
-
-    public static InventoryAccess getInventoryAccess() {
-        return inventoryAccess;
-    }
-
-    public static AnySilentChest getAnySilentChest() {
-        return anySilentChest;
-    }
-
-    public static Object getFromConfig(String path, Object defaultValue) {
-        Object val = mainPlugin.getConfig().get(path);
-        if (val == null) {
-            mainPlugin.getConfig().set(path, defaultValue);
-            return defaultValue;
-        }
-        else {
-            return val;
-        }
-    }
-
-    public static void saveToConfig(String path, Object value) {
-        mainPlugin.getConfig().set(path, value);
-        mainPlugin.saveConfig();
-    }
-
-    public static Material getOpenInvItem() {
-        if (!mainPlugin.getConfig().isSet("items.open-inv")) {
-            saveToConfig("items.open-inv", "STICK");
-        }
-
-        String itemName = mainPlugin.getConfig().getString("items.open-inv", "STICK");
-        Material material = Material.getMaterial(itemName);
-        if (material == null) {
-            mainPlugin.getLogger().warning("OpenInv item '" + itemName + "' does not match to a valid item. Defaulting to stick.");
-            material = Material.STICK;
-        }
-
-        return material;
-    }
-
-    public static boolean notifySilentChest() {
-        return mainPlugin.getConfig().getBoolean("notify.silent-chest", true);
-    }
-
-    public static boolean notifyAnyChest() {
-        return mainPlugin.getConfig().getBoolean("notify.any-chest", true);
-    }
-
-    public static boolean getPlayerAnyChestStatus(Player player) {
-        return mainPlugin.getConfig().getBoolean("toggles.any-chest." + player.getUniqueId(), false);
-    }
-
-    public static void setPlayerAnyChestStatus(Player player, boolean status) {
-        saveToConfig("toggles.any-chest." + player.getUniqueId(), status);
-    }
-
-    public static boolean getPlayerItemOpenInvStatus(Player player) {
-        return mainPlugin.getConfig().getBoolean("toggles.items.open-inv" + player.getUniqueId(), false);
-    }
-
-    public static void setPlayerItemOpenInvStatus(Player player, boolean status) {
-        saveToConfig("toggles.items.open-inv." + player.getUniqueId(), status);
-    }
-
-    public static boolean getPlayerSilentChestStatus(Player player) {
-        return mainPlugin.getConfig().getBoolean("toggles.silent-chest." + player.getUniqueId(), false);
-    }
-
-    public static void setPlayerSilentChestStatus(Player player, boolean status) {
-        saveToConfig("toggles.silent-chest." + player.getUniqueId(), status);
-    }
-
-    public static void log(String text) {
-        mainPlugin.getLogger().info("[OpenInv] " + text);
-    }
-
-    public static void log(Throwable e) {
-        mainPlugin.getLogger().severe("[OpenInv] " + e.toString());
-        e.printStackTrace();
-    }
-
-    public static void sendMessage(CommandSender sender, String message) {
-        sender.sendMessage(ChatColor.AQUA + "[OpenInv] " + ChatColor.WHITE + message);
-    }
-
-    public static void showHelp(Player player) {
-        player.sendMessage(ChatColor.GREEN + "/openinv <player> - Open a player's inventory.");
-        player.sendMessage(ChatColor.GREEN + "   (aliases: oi, inv, open)");
-
-        player.sendMessage(ChatColor.GREEN + "/openender <player> - Open a player's ender chest.");
-        player.sendMessage(ChatColor.GREEN + "   (aliases: oe)");
-
-        player.sendMessage(ChatColor.GREEN + "/searchinv <item> [minAmount] -");
-        player.sendMessage(ChatColor.GREEN + "   Search and list players having a specific item.");
-        player.sendMessage(ChatColor.GREEN + "   (aliases: si)");
-
-        player.sendMessage(ChatColor.GREEN + "/searchender <item> [minAmount] -");
-        player.sendMessage(ChatColor.GREEN + "   Search and list players having a specific item.");
-        player.sendMessage(ChatColor.GREEN + "   (aliases: se)");
-
-        player.sendMessage(ChatColor.GREEN + "/toggleopeninv - Toggle the item openinv function.");
-        player.sendMessage(ChatColor.GREEN + "   (aliases: toi, toggleoi, toggleinv)");
-
-        player.sendMessage(ChatColor.GREEN + "/anychest - Toggle the any chest function.");
-        player.sendMessage(ChatColor.GREEN + "   (aliases: ac)");
-
-        player.sendMessage(ChatColor.GREEN + "/silentchest - Toggle the silent chest function.");
-        player.sendMessage(ChatColor.GREEN + "   (aliases: sc, silent)");
-    }
-
-    public static boolean hasPermission(Permissible player, String permission) {
-        String[] parts = permission.split("\\.");
-        String perm = "";
-        for (int i = 0; i < parts.length; i++) {
-            if (player.hasPermission(perm + "*")) {
-                return true;
-            }
-            perm += parts[i] + ".";
-        }
-        return player.hasPermission(permission);
-    }
-}

src/main/java/com/lishid/openinv/commands/AnyChestCommand.java

@@ -1,62 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.commands;
-
-import org.bukkit.ChatColor;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-
-public class AnyChestCommand implements CommandExecutor {
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (command.getName().equalsIgnoreCase("anychest")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + "You can't use this command from the console.");
-                return true;
-            }
-
-            if (!OpenInv.hasPermission(sender, Permissions.PERM_ANYCHEST)) {
-                sender.sendMessage(ChatColor.RED + "You do not have permission to use any chest.");
-                return true;
-            }
-
-            Player player = (Player) sender;
-
-            if (args.length > 0) {
-                if (args[0].equalsIgnoreCase("check")) {
-                    String status = OpenInv.getPlayerAnyChestStatus(player) ? ChatColor.GREEN + "ON" : ChatColor.RED + "OFF";
-                    OpenInv.sendMessage(player, "Any Chest is " + status + ChatColor.RESET + ".");
-                    return true;
-                }
-            }
-
-            OpenInv.setPlayerAnyChestStatus(player, !OpenInv.getPlayerAnyChestStatus(player));
-
-            String status = OpenInv.getPlayerAnyChestStatus(player) ? ChatColor.GREEN + "ON" : ChatColor.RED + "OFF";
-            OpenInv.sendMessage(player, "Any Chest is now " + status + ChatColor.RESET + ".");
-
-            return true;
-        }
-
-        return false;
-    }
-}

src/main/java/com/lishid/openinv/commands/OpenEnderCommand.java

@@ -1,164 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.commands;
-
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-import com.lishid.openinv.internal.SpecialEnderChest;
-import com.lishid.openinv.utils.UUIDUtil;
-
-public class OpenEnderCommand implements CommandExecutor {
-    private final OpenInv plugin;
-    private final Map<UUID, UUID> openEnderHistory = new ConcurrentHashMap<UUID, UUID>();
-
-    public OpenEnderCommand(OpenInv plugin) {
-        this.plugin = plugin;
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (command.getName().equalsIgnoreCase("openender")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + "You can't use this command from the console.");
-                return true;
-            }
-
-            if (!OpenInv.hasPermission(sender, Permissions.PERM_ENDERCHEST)) {
-                sender.sendMessage(ChatColor.RED + "You do not have permission to access player ender chests.");
-                return true;
-            }
-
-            if (args.length > 0 && args[0].equalsIgnoreCase("?")) {
-                OpenInv.showHelp((Player) sender);
-                return true;
-            }
-
-            final Player player = (Player) sender;
-
-            // History management
-            UUID history = openEnderHistory.get(player.getUniqueId());
-            if (history == null) {
-                history = player.getUniqueId();
-                openEnderHistory.put(player.getUniqueId(), history);
-            }
-
-            final UUID uuid;
-
-            // Read from history if target is not named
-            if (args.length < 1) {
-                if (history != null) {
-                    uuid = history;
-                }
-                else {
-                    sender.sendMessage(ChatColor.RED + "OpenEnder history is empty!");
-                    return true;
-                }
-            }
-            else {
-                uuid = UUIDUtil.getUUIDOf(args[0]);
-                if (uuid == null) {
-                    player.sendMessage(ChatColor.RED + "Player not found!");
-                    return true;
-                }
-            }
-
-            final UUID playerUUID = player.getUniqueId();
-
-            Player target = Bukkit.getPlayer(uuid);
-            if (target == null) {
-                // Targeted player was not found online, start asynchronous lookup in files
-                Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
-                    @Override
-                    public void run() {
-                        // Try loading the player's data asynchronously
-                        final Player target = OpenInv.getPlayerLoader().loadPlayer(uuid);
-                        if (target == null) {
-                            player.sendMessage(ChatColor.RED + "Player not found!");
-                            return;
-                        }
-
-                        // Open target's inventory synchronously
-                        Bukkit.getScheduler().runTask(plugin, new Runnable() {
-                            @Override
-                            public void run() {
-                                Player player = Bukkit.getPlayer(playerUUID);
-                                // If sender is no longer online after loading the target, abort!
-                                if (player == null) {
-                                    return;
-                                }
-                                openInventory(player, target);
-                            }
-                        });
-                    }
-                });
-            } else {
-                openInventory(player, target);
-            }
-
-            return true;
-        }
-
-        return false;
-    }
-
-    private void openInventory(Player player, Player target) {
-        if (target == null) {
-            player.sendMessage(ChatColor.RED + "Player not found!");
-            return;
-        }
-
-        if (target != player && !OpenInv.hasPermission(player, Permissions.PERM_ENDERCHEST_ALL)) {
-            player.sendMessage(ChatColor.RED + "You do not have permission to access other player's ender chests.");
-            return;
-        }
-
-        // Permissions checks
-        if (!OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE) && OpenInv.hasPermission(target, Permissions.PERM_EXEMPT)) {
-            player.sendMessage(ChatColor.RED + target.getDisplayName() + "'s ender chest is protected!");
-            return;
-        }
-
-        // Crossworld check
-        if ((!OpenInv.hasPermission(player, Permissions.PERM_CROSSWORLD) && !OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE)) && target.getWorld() != player.getWorld()) {
-            player.sendMessage(ChatColor.RED + target.getDisplayName() + " is not in your world!");
-            return;
-        }
-
-        // Record the target
-        openEnderHistory.put(player.getUniqueId(), target.getUniqueId());
-
-        // Create the inventory
-        SpecialEnderChest chest = OpenInv.enderChests.get(target.getUniqueId());
-        if (chest == null) {
-            chest = new SpecialEnderChest(target, target.isOnline());
-        }
-
-        // Open the inventory
-        player.openInventory(chest.getBukkitInventory());
-    }
-}

src/main/java/com/lishid/openinv/commands/OpenInvCommand.java

@@ -1,158 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.commands;
-
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-import com.lishid.openinv.internal.SpecialPlayerInventory;
-import com.lishid.openinv.utils.UUIDUtil;
-
-public class OpenInvCommand implements CommandExecutor {
-    private final OpenInv plugin;
-    private final Map<UUID, UUID> openInvHistory = new ConcurrentHashMap<UUID, UUID>();
-
-    public OpenInvCommand(OpenInv plugin) {
-        this.plugin = plugin;
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (command.getName().equalsIgnoreCase("openinv")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + "You can't use this command from the console.");
-                return true;
-            }
-            if (!OpenInv.hasPermission(sender, Permissions.PERM_OPENINV)) {
-                sender.sendMessage(ChatColor.RED + "You do not have permission to access player inventories.");
-                return true;
-            }
-
-            if (args.length > 0 && args[0].equalsIgnoreCase("?")) {
-                OpenInv.showHelp((Player) sender);
-                return true;
-            }
-
-            final Player player = (Player) sender;
-
-            // History management
-            UUID history = openInvHistory.get(player.getUniqueId());
-            if (history == null) {
-                history = player.getUniqueId();
-                openInvHistory.put(player.getUniqueId(), history);
-            }
-
-            final UUID uuid;
-
-            // Read from history if target is not named
-            if (args.length < 1) {
-                uuid = history;
-            }
-            else {
-                uuid = UUIDUtil.getUUIDOf(args[0]);
-                if (uuid == null) {
-                    player.sendMessage(ChatColor.RED + "Player not found!");
-                    return true;
-                }
-            }
-
-            final UUID playerUUID = player.getUniqueId();
-
-            Player target = Bukkit.getPlayer(uuid);
-            if (target == null) {
-                // Targeted player was not found online, start asynchronous lookup in files
-                Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
-                    @Override
-                    public void run() {
-                        // Try loading the player's data asynchronously
-                        final Player target = OpenInv.getPlayerLoader().loadPlayer(uuid);
-                        if (target == null) {
-                            player.sendMessage(ChatColor.RED + "Player not found!");
-                            return;
-                        }
-
-                        // Open target's inventory synchronously
-                        Bukkit.getScheduler().runTask(plugin, new Runnable() {
-                            @Override
-                            public void run() {
-                                Player player = Bukkit.getPlayer(playerUUID);
-                                // If sender is no longer online after loading the target, abort!
-                                if (player == null) {
-                                    return;
-                                }
-                                openInventory(player, target);
-                            }
-                        });
-                    }
-                });
-            } else {
-                openInventory(player, target);
-            }
-
-            return true;
-        }
-
-        return false;
-    }
-
-    private void openInventory(Player player, Player target) {
-        if (target == null) {
-            player.sendMessage(ChatColor.RED + "Player not found!");
-            return;
-        }
-
-        // Permissions checks
-        if (!OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE) && OpenInv.hasPermission(target, Permissions.PERM_EXEMPT)) {
-            player.sendMessage(ChatColor.RED + target.getDisplayName() + "'s inventory is protected!");
-            return;
-        }
-
-        // Crossworld check
-        if ((!OpenInv.hasPermission(player, Permissions.PERM_CROSSWORLD) && !OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE)) && target.getWorld() != player.getWorld()) {
-            player.sendMessage(ChatColor.RED + target.getDisplayName() + " is not in your world!");
-            return;
-        }
-
-        // Self-open check
-        if (!OpenInv.hasPermission(player, Permissions.PERM_OPENSELF) && target.equals(player)) {
-            player.sendMessage(ChatColor.RED + "You're not allowed to openinv yourself.");
-            return;
-        }
-
-        // Record the target
-        openInvHistory.put(player.getUniqueId(), target.getUniqueId());
-
-        // Create the inventory
-        SpecialPlayerInventory inv = OpenInv.inventories.get(target.getUniqueId());
-        if (inv == null) {
-            inv = new SpecialPlayerInventory(target, target.isOnline());
-        }
-
-        // Open the inventory
-        player.openInventory(inv.getBukkitInventory());
-    }
-}

src/main/java/com/lishid/openinv/commands/SearchEnderCommand.java

@@ -1,65 +0,0 @@
-package com.lishid.openinv.commands;
-
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-
-public class SearchEnderCommand implements CommandExecutor {
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (command.getName().equalsIgnoreCase("searchender")) {
-            if (sender instanceof Player) {
-                if (!OpenInv.hasPermission(sender, Permissions.PERM_SEARCH)) {
-                    sender.sendMessage(ChatColor.RED + "You do not have permission to search player ender chests.");
-                    return true;
-                }
-            }
-
-            Material material = null;
-            int count = 1;
-
-            if (args.length >= 1) {
-                String[] gData;
-                gData = args[0].split(":");
-                material = Material.matchMaterial(gData[0]);
-            }
-            if (args.length >= 2) {
-                try {
-                    count = Integer.parseInt(args[1]);
-                }
-                catch (NumberFormatException ex) {
-                    sender.sendMessage(ChatColor.RED + "'" + args[1] + "' is not a number!");
-                    return false;
-                }
-            }
-
-            if (material == null) {
-                sender.sendMessage(ChatColor.RED + "Unknown item");
-                return false;
-            }
-
-            StringBuilder sb = new StringBuilder();
-
-            for (Player onlinePlayer : Bukkit.getServer().getOnlinePlayers()) {
-                if (onlinePlayer.getEnderChest().contains(material, count)) {
-                    sb.append(onlinePlayer.getName());
-                    sb.append("  ");
-                }
-            }
-
-            String playerList = sb.toString();
-            sender.sendMessage("Players with the item " + ChatColor.GRAY + material.toString() + ChatColor.RESET + " in their ender chest:  " + playerList);
-
-            return true;
-        }
-
-        return false;
-    }
-}

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

@@ -1,81 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.commands;
-
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-
-public class SearchInvCommand implements CommandExecutor {
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (command.getName().equalsIgnoreCase("searchinv")) {
-            if (sender instanceof Player) {
-                if (!OpenInv.hasPermission(sender, Permissions.PERM_SEARCH)) {
-                    sender.sendMessage(ChatColor.RED + "You do not have permission to search player inventories.");
-                    return true;
-                }
-            }
-
-            Material material = null;
-            int count = 1;
-
-            if (args.length >= 1) {
-                String[] gData;
-                gData = args[0].split(":");
-                material = Material.matchMaterial(gData[0]);
-            }
-            if (args.length >= 2) {
-                try {
-                    count = Integer.parseInt(args[1]);
-                }
-                catch (NumberFormatException ex) {
-                    sender.sendMessage(ChatColor.RED + "'" + args[1] + "' is not a number!");
-                    return false;
-                }
-            }
-
-            if (material == null) {
-                sender.sendMessage(ChatColor.RED + "Unknown item");
-                return false;
-            }
-
-            StringBuilder sb = new StringBuilder();
-
-            for (Player onlinePlayer : Bukkit.getServer().getOnlinePlayers()) {
-                if (onlinePlayer.getInventory().contains(material, count)) {
-                    sb.append(onlinePlayer.getName());
-                    sb.append("  ");
-                }
-            }
-
-            String playerList = sb.toString();
-            sender.sendMessage("Players with the item " + ChatColor.GRAY + material.toString() + ChatColor.RESET + " in their inventory:  " + playerList);
-
-            return true;
-        }
-
-        return false;
-    }
-}

src/main/java/com/lishid/openinv/commands/SilentChestCommand.java

@@ -1,62 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.commands;
-
-import org.bukkit.ChatColor;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-
-public class SilentChestCommand implements CommandExecutor {
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (command.getName().equalsIgnoreCase("silentchest")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + "You can't use this command from the console.");
-                return true;
-            }
-
-            if (!OpenInv.hasPermission(sender, Permissions.PERM_SILENT)) {
-                sender.sendMessage(ChatColor.RED + "You do not have permission to use silent chest.");
-                return true;
-            }
-
-            Player player = (Player) sender;
-
-            if (args.length > 0) {
-                if (args[0].equalsIgnoreCase("check")) {
-                    String status = OpenInv.getPlayerSilentChestStatus(player) ? ChatColor.GREEN + "ON" : ChatColor.RED + "OFF";
-                    OpenInv.sendMessage(player, "Silent Chest is " + status + ChatColor.RESET + ".");
-                    return true;
-                }
-            }
-
-            OpenInv.setPlayerSilentChestStatus(player, !OpenInv.getPlayerSilentChestStatus(player));
-
-            String status = OpenInv.getPlayerSilentChestStatus(player) ? ChatColor.GREEN + "ON" : ChatColor.RED + "OFF";
-            OpenInv.sendMessage(player, "Silent Chest is now " + status + ChatColor.RESET + ".");
-
-            return true;
-        }
-
-        return false;
-    }
-}

src/main/java/com/lishid/openinv/commands/ToggleOpenInvCommand.java

@@ -1,62 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.commands;
-
-import org.bukkit.ChatColor;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-
-public class ToggleOpenInvCommand implements CommandExecutor {
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (command.getName().equalsIgnoreCase("toggleopeninv")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + "You can't use this command from the console.");
-                return true;
-            }
-
-            if (!OpenInv.hasPermission(sender, Permissions.PERM_OPENINV)) {
-                sender.sendMessage(ChatColor.RED + "You do not have permission to access player inventories.");
-                return true;
-            }
-
-            Player player = (Player) sender;
-
-            if (args.length > 0) {
-                if (args[0].equalsIgnoreCase("check")) {
-                    String status = OpenInv.getPlayerItemOpenInvStatus(player) ? ChatColor.GREEN + "ON" : ChatColor.RED + "OFF";
-                    OpenInv.sendMessage(player, "OpenInv with " + ChatColor.GRAY + OpenInv.getOpenInvItem() + ChatColor.RESET + status + ChatColor.RESET + ".");
-                    return true;
-                }
-            }
-
-            OpenInv.setPlayerItemOpenInvStatus(player, !OpenInv.getPlayerItemOpenInvStatus(player));
-
-            String status = OpenInv.getPlayerItemOpenInvStatus(player) ? ChatColor.GREEN + "ON" : ChatColor.RED + "OFF";
-            OpenInv.sendMessage(player, "OpenInv with " + ChatColor.GRAY + OpenInv.getOpenInvItem() + ChatColor.RESET + " is now " + status + ChatColor.RESET + ".");
-
-            return true;
-        }
-
-        return false;
-    }
-}

src/main/java/com/lishid/openinv/internal/AnySilentChest.java

@@ -1,141 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal;
-
-import java.util.Iterator;
-
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
-
-import org.bukkit.craftbukkit.v1_8_R3.entity.*;
-
-public class AnySilentChest {
-    public boolean isAnyChestNeeded(Player p, int x, int y, int z) {
-        // FOR REFERENCE, LOOK AT net.minecraft.server.BlockChest
-        BlockPosition position = new BlockPosition(x, y, z);
-        EntityPlayer player = ((CraftPlayer) p).getHandle();
-        World world = player.world;
-        BlockChest chest = (BlockChest) (((BlockChest) world.getType(position).getBlock()).b == 1 ?
-                Block.getByName("trapped_chest") : Block.getByName("chest"));
-
-        // If block on top
-        if (topBlocking(world, position)) {
-            return true;
-        }
-
-        // If block next to chest is chest and has a block on top
-        for (EnumDirection direction : EnumDirectionList.HORIZONTAL) {
-            BlockPosition sidePosition = position.shift(direction);
-            Block var8 = world.getType(sidePosition).getBlock();
-            if (var8 == chest) {
-                if (this.topBlocking(world, sidePosition)) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-    private boolean topBlocking(World world, BlockPosition position) {
-        return this.blockOnTop(world, position) || this.ocelotOnTop(world, position);
-    }
-
-    private boolean blockOnTop(World world, BlockPosition position) {
-        return world.getType(position.up()).getBlock().isOccluding();
-    }
-
-    private boolean ocelotOnTop(World world, BlockPosition position) {
-        Iterator var3 = world.a(EntityOcelot.class,
-                new AxisAlignedBB((double) position.getX(), (double) (position.getY() + 1),
-                        (double) position.getZ(), (double) (position.getX() + 1),
-                        (double) (position.getY() + 2), (double) (position.getZ() + 1))).iterator();
-
-        EntityOcelot var5;
-        do {
-            if (!var3.hasNext()) {
-                return false;
-            }
-
-            Entity var4 = (Entity) var3.next();
-            var5 = (EntityOcelot) var4;
-        } while (!var5.isSitting());
-
-        return true;
-    }
-
-    public boolean activateChest(Player p, boolean anyChest, boolean silentChest, int x, int y, int z) {
-        BlockPosition position = new BlockPosition(x, y, z);
-        EntityPlayer player = ((CraftPlayer) p).getHandle();
-        World world = player.world;
-        if (world.isClientSide) {
-            return true;
-        }
-
-        BlockChest chest = (BlockChest) (((BlockChest) world.getType(position).getBlock()).b == 1 ?
-                Block.getByName("trapped_chest") : Block.getByName("chest"));
-
-        TileEntity tileEntity = world.getTileEntity(position);
-        if (!(tileEntity instanceof TileEntityChest)) {
-            return true;
-        }
-
-        ITileInventory tileInventory = (ITileInventory) tileEntity;
-        if (!anyChest && this.topBlocking(world, position)) {
-            return true;
-        }
-
-        for (EnumDirection direction : EnumDirectionList.HORIZONTAL) {
-            BlockPosition side = position.shift(direction);
-            Block block = world.getType(side).getBlock();
-            if (block == chest) {
-                if (!anyChest && this.topBlocking(world, side)) {
-                    return true;
-                }
-
-                TileEntity sideTileEntity = world.getTileEntity(side);
-                if (sideTileEntity instanceof TileEntityChest) {
-                    if (direction != EnumDirection.WEST && direction != EnumDirection.NORTH) {
-                        tileInventory = new InventoryLargeChest("container.chestDouble", tileInventory, (TileEntityChest) sideTileEntity);
-                    } else {
-                        tileInventory = new InventoryLargeChest("container.chestDouble", (TileEntityChest) sideTileEntity, tileInventory);
-                    }
-                }
-            }
-        }
-
-        boolean returnValue = true;
-        if (silentChest) {
-            tileInventory = new SilentInventory(tileInventory);
-            if (OpenInv.notifySilentChest()) {
-                OpenInv.sendMessage(p, "You are opening a chest silently.");
-            }
-            returnValue = false;
-        }
-
-        player.openContainer(tileInventory);
-
-        if (anyChest && OpenInv.notifyAnyChest()) {
-            OpenInv.sendMessage(p, "You are opening a blocked chest.");
-        }
-
-        return returnValue;
-    }
-}

src/main/java/com/lishid/openinv/internal/EnumDirectionList.java

@@ -1,24 +0,0 @@
-package com.lishid.openinv.internal;
-
-import java.util.Iterator;
-
-import com.google.common.collect.Iterators;
-
-import net.minecraft.server.v1_8_R3.EnumDirection;
-import net.minecraft.server.v1_8_R3.EnumDirection.EnumDirectionLimit;
-
-public enum EnumDirectionList implements Iterable<EnumDirection> {
-    HORIZONTAL(EnumDirectionLimit.HORIZONTAL),
-    VERTICAL(EnumDirectionLimit.VERTICAL);
-
-    private final EnumDirectionLimit list;
-
-    private EnumDirectionList(EnumDirectionLimit list) {
-        this.list = list;
-    }
-
-    @Override
-    public Iterator<EnumDirection> iterator() {
-        return Iterators.forArray(list.a());
-    }
-}

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

@@ -1,60 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal;
-
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.entity.Player;
-
-import com.lishid.openinv.OpenInv;
-import com.mojang.authlib.GameProfile;
-
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
-
-import org.bukkit.craftbukkit.v1_8_R3.*;
-
-public class PlayerDataManager {
-    public Player loadPlayer(UUID uuid) {
-        try {
-            OfflinePlayer player = Bukkit.getOfflinePlayer(uuid);
-            if (player == null || !player.hasPlayedBefore()) {
-                return null;
-            }
-            GameProfile profile = new GameProfile(uuid, player.getName());
-            MinecraftServer server = ((CraftServer) Bukkit.getServer()).getServer();
-            // Create an entity to load the player data
-            EntityPlayer entity = new EntityPlayer(server, server.getWorldServer(0), profile, new PlayerInteractManager(server.getWorldServer(0)));
-
-            // Get the bukkit entity
-            Player target = entity.getBukkitEntity();
-            if (target != null) {
-                // Load data
-                target.loadData();
-                // Return the entity
-                return target;
-            }
-        }
-        catch (Exception e) {
-            OpenInv.log(e);
-        }
-
-        return null;
-    }
-}

src/main/java/com/lishid/openinv/internal/SilentInventory.java

@@ -1,164 +0,0 @@
-package com.lishid.openinv.internal;
-
-import java.util.List;
-
-import org.bukkit.craftbukkit.v1_8_R3.entity.CraftHumanEntity;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.inventory.InventoryHolder;
-
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
-
-public class SilentInventory implements ITileInventory {
-    public ITileInventory inv;
-
-    public SilentInventory(ITileInventory inv) {
-        this.inv = inv;
-    }
-
-    @Override
-    public boolean r_() {
-        return inv.r_();
-    }
-
-    @Override
-    public void a(ChestLock chestLock) {
-        inv.a(chestLock);
-    }
-
-    @Override
-    public ChestLock i() {
-        return inv.i();
-    }
-
-    @Override
-    public int getSize() {
-        return inv.getSize();
-    }
-
-    @Override
-    public ItemStack getItem(int i) {
-        return inv.getItem(i);
-    }
-
-    @Override
-    public ItemStack splitStack(int i, int i1) {
-        return inv.splitStack(i, i1);
-    }
-
-    @Override
-    public ItemStack splitWithoutUpdate(int i) {
-        return inv.splitWithoutUpdate(i);
-    }
-
-    @Override
-    public void setItem(int i, ItemStack itemStack) {
-        inv.setItem(i, itemStack);
-    }
-
-    @Override
-    public int getMaxStackSize() {
-        return inv.getMaxStackSize();
-    }
-
-    @Override
-    public void update() {
-        inv.update();
-    }
-
-    @Override
-    public boolean a(EntityHuman entityHuman) {
-        return inv.a(entityHuman);
-    }
-
-    @Override
-    public void startOpen(EntityHuman entityHuman) {
-        // Don't do anything
-    }
-
-    @Override
-    public void closeContainer(EntityHuman entityHuman) {
-        // Don't do anything
-    }
-
-    @Override
-    public boolean b(int i, ItemStack itemStack) {
-        return inv.b(i, itemStack);
-    }
-
-    @Override
-    public int getProperty(int i) {
-        return inv.getProperty(i);
-    }
-
-    @Override
-    public void b(int i, int i1) {
-        inv.b(i, i1);
-    }
-
-    @Override
-    public int g() {
-        return inv.g();
-    }
-
-    @Override
-    public void l() {
-        inv.l();
-    }
-
-    @Override
-    public ItemStack[] getContents() {
-        return inv.getContents();
-    }
-
-    @Override
-    public void onOpen(CraftHumanEntity craftHumanEntity) {
-        inv.onOpen(craftHumanEntity);
-    }
-
-    @Override
-    public void onClose(CraftHumanEntity craftHumanEntity) {
-        inv.onClose(craftHumanEntity);
-    }
-
-    @Override
-    public List<HumanEntity> getViewers() {
-        return inv.getViewers();
-    }
-
-    @Override
-    public InventoryHolder getOwner() {
-        return inv.getOwner();
-    }
-
-    @Override
-    public void setMaxStackSize(int i) {
-        inv.setMaxStackSize(i);
-    }
-
-    @Override
-    public String getName() {
-        return inv.getName();
-    }
-
-    @Override
-    public boolean hasCustomName() {
-        return inv.hasCustomName();
-    }
-
-    @Override
-    public IChatBaseComponent getScoreboardDisplayName() {
-        return inv.getScoreboardDisplayName();
-    }
-
-    @Override
-    public Container createContainer(PlayerInventory playerInventory, EntityHuman entityHuman) {
-        // Don't let the chest itself create the container.
-        return new ContainerChest(playerInventory, this, entityHuman);
-    }
-
-    @Override
-    public String getContainerName() {
-        return inv.getContainerName();
-    }
-}

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

@@ -1,96 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.internal;
-
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.InventoryHolder;
-
-import com.lishid.openinv.OpenInv;
-
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
-
-import org.bukkit.craftbukkit.v1_8_R3.entity.*;
-import org.bukkit.craftbukkit.v1_8_R3.inventory.*;
-
-public class SpecialEnderChest extends InventorySubcontainer {
-    private final CraftInventory inventory = new CraftInventory(this);
-    private final InventoryEnderChest enderChest;
-    private final CraftPlayer owner;
-    private boolean playerOnline;
-
-    public SpecialEnderChest(Player p, boolean online) {
-        this(p, ((CraftPlayer) p).getHandle().getEnderChest(), online);
-    }
-
-    public SpecialEnderChest(Player p, InventoryEnderChest enderChest, boolean online) {
-        super(enderChest.getName(), enderChest.hasCustomName(), enderChest.getSize());
-        this.owner = (CraftPlayer) p;
-        this.enderChest = enderChest;
-        this.items = this.enderChest.getContents();
-        this.playerOnline = online;
-        OpenInv.enderChests.put(owner.getUniqueId(), this);
-    }
-
-    private void saveOnExit() {
-        if (transaction.isEmpty() && !playerOnline) {
-            owner.saveData();
-            OpenInv.enderChests.remove(owner.getUniqueId());
-        }
-    }
-
-    private void linkInventory(InventoryEnderChest inventory) {
-        inventory.items = this.items;
-    }
-
-    public Inventory getBukkitInventory() {
-        return inventory;
-    }
-
-    public void playerOnline(Player p) {
-        if (!playerOnline) {
-            linkInventory(((CraftPlayer) p).getHandle().getEnderChest());
-            p.saveData();
-            playerOnline = true;
-        }
-    }
-
-    public void playerOffline() {
-        playerOnline = false;
-        owner.loadData();
-        linkInventory(owner.getHandle().getEnderChest());
-        saveOnExit();
-    }
-
-    @Override
-    public void onClose(CraftHumanEntity who) {
-        super.onClose(who);
-        saveOnExit();
-    }
-
-    @Override
-    public InventoryHolder getOwner() {
-        return this.owner;
-    }
-
-    @Override
-    public void update() {
-        super.update();
-        enderChest.update();
-    }
-}

src/main/java/com/lishid/openinv/listeners/OpenInvEntityListener.java

@@ -1,54 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.listeners;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-
-public class OpenInvEntityListener implements Listener {
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
-        Entity attacker = event.getDamager();
-        Entity defender = event.getEntity();
-
-        if (!(attacker instanceof Player) || !(defender instanceof Player)) {
-            return;
-        }
-
-        Player player = (Player) attacker;
-
-        if (player.getItemInHand().getType() == OpenInv.getOpenInvItem()) {
-            if (!OpenInv.getPlayerItemOpenInvStatus(player) || !OpenInv.hasPermission(player, Permissions.PERM_OPENINV)) {
-                return;
-            }
-
-            Player target = (Player) defender;
-
-            event.setDamage(0);
-            event.setCancelled(true);
-
-            player.performCommand("openinv " + target.getName());
-        }
-    }
-}

src/main/java/com/lishid/openinv/listeners/OpenInvPlayerListener.java

@@ -1,151 +0,0 @@
-/*
- * 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 <http://www.gnu.org/licenses/>.
- */
-
-package com.lishid.openinv.listeners;
-
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.Chest;
-import org.bukkit.block.Sign;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Event.Result;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-
-import com.lishid.openinv.OpenInv;
-import com.lishid.openinv.Permissions;
-import com.lishid.openinv.internal.SpecialEnderChest;
-import com.lishid.openinv.internal.SpecialPlayerInventory;
-
-public class OpenInvPlayerListener implements Listener {
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        Player player = event.getPlayer();
-
-        SpecialPlayerInventory inventory = OpenInv.inventories.get(player.getUniqueId());
-        if (inventory != null) {
-            inventory.playerOnline(event.getPlayer());
-        }
-
-        SpecialEnderChest chest = OpenInv.enderChests.get(player.getUniqueId());
-        if (chest != null) {
-            chest.playerOnline(event.getPlayer());
-        }
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR)
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        Player player = event.getPlayer();
-
-        SpecialPlayerInventory inventory = OpenInv.inventories.get(player.getUniqueId());
-        if (inventory != null) {
-            inventory.playerOffline();
-        }
-
-        SpecialEnderChest chest = OpenInv.enderChests.get(player.getUniqueId());
-        if (chest != null) {
-            chest.playerOffline();
-        }
-    }
-
-    @EventHandler
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        Player player = event.getPlayer();
-
-        if (player.isSneaking()) {
-            return;
-        }
-
-        Action action = event.getAction();
-        Block block = event.getClickedBlock();
-
-        switch (action) {
-            case RIGHT_CLICK_BLOCK:
-                if (event.useInteractedBlock() == Result.DENY) {
-                    return;
-                }
-
-                // Ender Chests
-                if (block.getType() == Material.ENDER_CHEST) {
-                    if (OpenInv.hasPermission(player, Permissions.PERM_SILENT) && OpenInv.getPlayerSilentChestStatus(player)) {
-                        event.setCancelled(true);
-                        player.openInventory(player.getEnderChest());
-                        return;
-                    }
-                }
-
-                // Chests
-                if (block.getState() instanceof Chest) {
-                    boolean silentChest = false;
-                    boolean anyChest = false;
-                    int x = block.getX();
-                    int y = block.getY();
-                    int z = block.getZ();
-
-                    if (OpenInv.hasPermission(player, Permissions.PERM_SILENT) && OpenInv.getPlayerSilentChestStatus(player)) {
-                        silentChest = true;
-                    }
-
-                    if (OpenInv.hasPermission(player, Permissions.PERM_ANYCHEST) && OpenInv.getPlayerAnyChestStatus(player)) {
-                        try {
-                            anyChest = OpenInv.getAnySilentChest().isAnyChestNeeded(player, x, y, z);
-                        }
-                        catch (Exception e) {
-                            player.sendMessage(ChatColor.RED + "Error while executing openinv. Unsupported CraftBukkit.");
-                            e.printStackTrace();
-                        }
-                    }
-
-                    // If the anyChest or silentChest is active
-                    if (anyChest || silentChest) {
-                        if (!OpenInv.getAnySilentChest().activateChest(player, anyChest, silentChest, x, y, z)) {
-                            event.setCancelled(true);
-                        }
-                    }
-
-                    return;
-                }
-
-                // Signs
-                if (block.getState() instanceof Sign) {
-                    try {
-                        Sign sign = ((Sign) block.getState());
-                        if (OpenInv.hasPermission(player, Permissions.PERM_OPENINV) && sign.getLine(0).equalsIgnoreCase("[openinv]")) {
-                            String text = sign.getLine(1).trim() + sign.getLine(2).trim() + sign.getLine(3).trim();
-                            player.performCommand("openinv " + text);
-                        }
-                    }
-                    catch (Exception e) {
-                        player.sendMessage("Internal Error.");
-                        e.printStackTrace();
-                    }
-
-                    return;
-                }
-            case RIGHT_CLICK_AIR:
-                // OpenInv item
-                if (player.getItemInHand().getType() == OpenInv.getOpenInvItem() && OpenInv.getPlayerItemOpenInvStatus(player) && OpenInv.hasPermission(player, Permissions.PERM_OPENINV)) {
-                    player.performCommand("openinv");
-                }
-        }
-    }
-}

src/main/java/com/lishid/openinv/utils/UUIDFetcher.java

@@ -1,98 +0,0 @@
-package com.lishid.openinv.utils;
-
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.nio.ByteBuffer;
-import java.util.*;
-import java.util.concurrent.Callable;
-
-import org.json.simple.JSONArray;
-import org.json.simple.JSONObject;
-import org.json.simple.parser.JSONParser;
-
-import com.google.common.collect.ImmutableList;
-
-public class UUIDFetcher implements Callable<Map<String, UUID>> {
-    private static final double PROFILES_PER_REQUEST = 100;
-    private static final String PROFILE_URL = "https://api.mojang.com/profiles/minecraft";
-    private final JSONParser jsonParser = new JSONParser();
-    private final List<String> names;
-    private final boolean rateLimiting;
-
-    public UUIDFetcher(List<String> names, boolean rateLimiting) {
-        this.names = ImmutableList.copyOf(names);
-        this.rateLimiting = rateLimiting;
-    }
-
-    public UUIDFetcher(List<String> names) {
-        this(names, true);
-    }
-
-    @Override
-    public Map<String, UUID> call() throws Exception {
-        Map<String, UUID> uuidMap = new HashMap<String, UUID>();
-        int requests = (int) Math.ceil(names.size() / PROFILES_PER_REQUEST);
-        for (int i = 0; i < requests; i++) {
-            HttpURLConnection connection = createConnection();
-            String body = JSONArray.toJSONString(names.subList(i * 100, Math.min((i + 1) * 100, names.size())));
-            writeBody(connection, body);
-            JSONArray array = (JSONArray) jsonParser.parse(new InputStreamReader(connection.getInputStream()));
-            for (Object profile : array) {
-                JSONObject jsonProfile = (JSONObject) profile;
-                String id = (String) jsonProfile.get("id");
-                String name = (String) jsonProfile.get("name");
-                UUID uuid = UUIDFetcher.getUUID(id);
-                uuidMap.put(name.toLowerCase(), uuid);
-            }
-            if (rateLimiting && i != requests - 1) {
-                Thread.sleep(100L);
-            }
-        }
-        return uuidMap;
-    }
-
-    private static void writeBody(HttpURLConnection connection, String body) throws Exception {
-        OutputStream stream = connection.getOutputStream();
-        stream.write(body.getBytes());
-        stream.flush();
-        stream.close();
-    }
-
-    private static HttpURLConnection createConnection() throws Exception {
-        URL url = new URL(PROFILE_URL);
-        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
-        connection.setRequestMethod("POST");
-        connection.setRequestProperty("Content-Type", "application/json");
-        connection.setUseCaches(false);
-        connection.setDoInput(true);
-        connection.setDoOutput(true);
-        return connection;
-    }
-
-    private static UUID getUUID(String id) {
-        return UUID.fromString(id.substring(0, 8) + "-" + id.substring(8, 12) + "-" + id.substring(12, 16) + "-" + id.substring(16, 20) + "-" +id.substring(20, 32));
-    }
-
-    public static byte[] toBytes(UUID uuid) {
-        ByteBuffer byteBuffer = ByteBuffer.wrap(new byte[16]);
-        byteBuffer.putLong(uuid.getMostSignificantBits());
-        byteBuffer.putLong(uuid.getLeastSignificantBits());
-        return byteBuffer.array();
-    }
-
-    public static UUID fromBytes(byte[] array) {
-        if (array.length != 16) {
-            throw new IllegalArgumentException("Illegal byte array length: " + array.length);
-        }
-        ByteBuffer byteBuffer = ByteBuffer.wrap(array);
-        long mostSignificant = byteBuffer.getLong();
-        long leastSignificant = byteBuffer.getLong();
-        return new UUID(mostSignificant, leastSignificant);
-    }
-
-    public static UUID getUUIDOf(String name) throws Exception {
-        return new UUIDFetcher(Arrays.asList(name)).call().get(name);
-    }
-}

src/main/java/com/lishid/openinv/utils/UUIDUtil.java

@@ -1,62 +0,0 @@
-package com.lishid.openinv.utils;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Map;
-import java.util.UUID;
-
-import org.apache.commons.lang.Validate;
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.entity.Player;
-
-public class UUIDUtil {
-    private static Player getPlayer(String name) {
-        Validate.notNull(name, "Name cannot be null");
-
-        Player found = null;
-        String lowerName = name.toLowerCase();
-        int delta = Integer.MAX_VALUE;
-
-        Collection<? extends Player> players = Bukkit.getOnlinePlayers();
-        for (Player player : players) {
-            if (player.getName().toLowerCase().startsWith(lowerName)) {
-                int curDelta = player.getName().length() - lowerName.length();
-                if (curDelta < delta) {
-                    found = player;
-                    delta = curDelta;
-                }
-                if (curDelta == 0) break;
-            }
-        }
-
-        return found;
-    }
-
-    @SuppressWarnings("deprecation")
-    private static UUID getUUIDLocally(String name) {
-        OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(name);
-        return offlinePlayer.hasPlayedBefore() ? offlinePlayer.getUniqueId() : null;
-    }
-
-    public static UUID getUUIDOf(String name) {
-        Player player = getPlayer(name);
-
-        if (player != null) {
-            return player.getUniqueId();
-        }
-
-        if (Bukkit.getServer().getOnlineMode() && !Bukkit.getServer().isPrimaryThread()) {
-            UUIDFetcher fetcher = new UUIDFetcher(Arrays.asList(name));
-            try {
-                Map<String, UUID> response = fetcher.call();
-                return response.get(name.toLowerCase());
-            }
-            catch (Exception ignored) {
-                //Fallthrough to end of method
-            }
-        }
-
-        return getUUIDLocally(name);
-    }
-}

src/main/resources/config.yml

@@ -1,6 +0,0 @@
-config-version: 2
-notify:
-  any-chest: true
-  silent-chest: true
-items:
-  open-inv: STICK

src/main/resources/plugin.yml

@@ -1,44 +0,0 @@
-name: OpenInv
-main: com.lishid.openinv.OpenInv
-version: 2.3.1
-author: lishid
-description: >
-             This plugin allows you to open a player's inventory as a chest and interact with it in real time.
-commands:
-  openinv:
-    aliases: [oi, inv, open]
-    description: Opens a player's inventory.
-    usage: |
-           /<command> - Opens last person's inventory.
-           /<command> <player> - Opens a player's inventory.
-  openender:
-    aliases: [oe]
-    description: Opens a player's ender chest.
-    usage: |
-           /<command> - Opens last person's ender chest.
-           /<command> <player> - Opens a player's ender chest.
-  searchinv:
-    aliases: [si]
-    description: Searches and lists players that have a specific item in their inventory.
-    usage: |
-           /<command> <item> [minAmount] - Item can be the Item ID or the CraftBukkit Item Name, minAmount is the minimum amount to be considered.
-  searchender:
-    aliases: [se]
-    description: Searches and lists players that have a specific item in their ender chest.
-    usage: |
-           /<command> <item> [minAmount] - Item can be the Item ID or the CraftBukkit Item Name, minAmount is the minimum amount to be considered.
-  toggleopeninv:
-    aliases: [toi, toggleoi, toggleinv]
-    description: Toggles the item openinv function.
-    usage: |
-           /<command> [check] - Checks whether item openinv is enabled.
-  anychest:
-    aliases: [ac]
-    description: Toggles the any chest function, which allows opening of blocked chests.
-    usage: |
-           /<command> [check] - Checks whether any chest is enabled.
-  silentchest:
-    aliases: [sc, silent]
-    description: Toggles the silent chest function, which hides the animation of a chest when opened or closed, and suppresses the sound.
-    usage: |
-           /<command> [check] - Checks whether silent chest is enabled.

src/plugin.yml

@@ -0,0 +1,39 @@
+name: OpenInv
+main: com.lishid.openinv.OpenInv
+version: 2.3.0
+author: lishid
+authors: [Jikoo]
+description: >
+             This plugin allows you to open a player's inventory as a chest and interact with it in real time.
+commands:
+  openinv:
+    aliases: [oi, inv, open]
+    description: Open a player's inventory
+    permission: OpenInv.openinv
+    usage: |
+           /<command> - Open last person's inventory
+           /<command> <Player> - Open a player's inventory
+  openender:
+    aliases: [oe]
+    description: Opens the enderchest of a player
+    permission: OpenInv.openender
+    usage: |
+           /<command> <Player> - Opens a player's enderchest
+  searchinv:
+    aliases: [si]
+    description: Search and list players having a specific item
+    permission: OpenInv.search
+    usage: |
+           /<command> <Item> [MinAmount] - Item can be the Item ID or the CraftBukkit Item Name, MinAmount is the minimum amount to be considered.
+  silentchest:
+    aliases: [sc, silent]
+    description: Toggle silent chest function, which hides the animation of a chest when opened or closed, and suppresses the sound.
+    permission: OpenInv.silent
+    usage: |
+           /<command> [Check] - Checks whether silent chest is enabled
+  anychest:
+    aliases: [ac]
+    description: Toggle anychest function, which allows opening of blocked chests.
+    permission: OpenInv.anychest
+    usage: |
+           /<command> [Check] - Checks whether anychest is enabled