Updated to Spigot 1.8

.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,206 @@
+/*
+ * 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.*;
+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;
+import com.lishid.openinv.utils.UpdateManager;
+
+/**
+ * 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>();
+
+    private UpdateManager updater = new UpdateManager();
+
+    public static OpenInv mainPlugin;
+
+    public static IPlayerDataManager playerLoader;
+    public static IInventoryAccess inventoryAccess;
+    public static IAnySilentChest anySilentChest;
+
+    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("CheckForUpdates", config.getBoolean("CheckForUpdates", true));
+        config.set("NotifySilentChest", config.getBoolean("NotifySilentChest", true));
+        config.set("NotifyAnyChest", config.getBoolean("NotifyAnyChest", true));
+        config.set("ItemOpenInvItemID", config.getInt("ItemOpenInvItemID", 280));
+        config.addDefault("ItemOpenInvItemID", 280);
+        config.addDefault("CheckForUpdates", true);
+        config.addDefault("NotifySilentChest", true);
+        config.addDefault("NotifyAnyChest", true);
+        config.options().copyDefaults(true);
+        saveConfig();
+
+        pm.registerEvents(new OpenInvPlayerListener(), this);
+        pm.registerEvents(new OpenInvEntityListener(), this);
+        pm.registerEvents(new OpenInvInventoryListener(), this);
+
+        getCommand("openinv").setExecutor(new OpenInvPluginCommand(this));
+        getCommand("searchinv").setExecutor(new SearchInvPluginCommand());
+        getCommand("toggleopeninv").setExecutor(new ToggleOpenInvPluginCommand());
+        getCommand("silentchest").setExecutor(new SilentChestPluginCommand(this));
+        getCommand("anychest").setExecutor(new AnyChestPluginCommand(this));
+        getCommand("openender").setExecutor(new OpenEnderPluginCommand(this));
+
+        updater.Initialize(this, getFile());
+    }
+
+    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/OpenInvEntityListener.java

@@ -1,54 +1,52 @@
-/*
- * 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());
-        }
-    }
-}
+/*
+ * 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.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+public class OpenInvEntityListener implements Listener {
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onEntityDamage(EntityDamageEvent event) {
+        if (event instanceof EntityDamageByEntityEvent) {
+            EntityDamageByEntityEvent evt = (EntityDamageByEntityEvent) event;
+            Entity attacker = evt.getDamager();
+            Entity defender = evt.getEntity();
+
+            if (!(attacker instanceof Player) || !(defender instanceof Player)) {
+                return;
+            }
+
+            Player player = (Player) attacker;
+
+            if (!(player.getItemInHand().getType().getId() == OpenInv.GetItemOpenInvItem()) || (!OpenInv.GetPlayerItemOpenInvStatus(player.getName())) || !OpenInv.hasPermission(player, "OpenInv.openinv")) {
+                return;
+            }
+
+            Player target = (Player) defender;
+            player.performCommand("openinv " + target.getName());
+
+            evt.setDamage(0);
+            evt.setCancelled(true);
+        }
+    }
+}

src/com/lishid/openinv/OpenInvInventoryListener.java

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

src/com/lishid/openinv/OpenInvPlayerListener.java

@@ -0,0 +1,133 @@
+/*
+ * 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();
+            }
+        }
+
+        if (event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK) {
+            if (!(player.getItemInHand().getType().getId() == OpenInv.GetItemOpenInvItem()) || (!OpenInv.GetPlayerItemOpenInvStatus(player.getName())) || !OpenInv.hasPermission(player, Permissions.PERM_OPENINV)) {
+                return;
+            }
+
+            player.performCommand("openinv");
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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 AnyChestPluginCommand implements CommandExecutor {
+    public AnyChestPluginCommand(OpenInv plugin) {
+
+    }
+
+    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 (!OpenInv.hasPermission(sender, Permissions.PERM_ANYCHEST)) {
+            sender.sendMessage(ChatColor.RED + "You do not have permission to use anychest.");
+            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,118 @@
+/*
+ * 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 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.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;
+    }
+
+    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 (!OpenInv.hasPermission(sender, Permissions.PERM_ENDERCHEST)) {
+            sender.sendMessage(ChatColor.RED + "You do not have permission to access player enderchest");
+            return true;
+        }
+
+        if (args.length > 0 && args[0].equalsIgnoreCase("?")) {
+            OpenInv.ShowHelp((Player) sender);
+            return true;
+        }
+
+        Player player = (Player) sender;
+        boolean offline = false;
+
+        // History management
+        String history = openEnderHistory.get(player);
+
+        if (history == null || history == "") {
+            history = player.getName();
+            openEnderHistory.put(player, history);
+        }
+
+        // Target selecting
+        Player target;
+
+        String name = "";
+
+        // Read from history if target is not named
+        if (args.length < 1) {
+            if (history != null && history != "") {
+                name = history;
+            }
+            else {
+                sender.sendMessage(ChatColor.RED + "OpenEnder history is empty!");
+                return true;
+            }
+        }
+        else {
+            name = args[0];
+        }
+
+        target = this.plugin.getServer().getPlayer(name);
+
+        if (target == null) {
+            // Try loading the player's data
+            target = OpenInv.playerLoader.loadPlayer(name);
+
+            if (target == null) {
+                sender.sendMessage(ChatColor.RED + "Player " + name + " not found!");
+                return true;
+            }
+        }
+
+        if (target != sender && !OpenInv.hasPermission(sender, Permissions.PERM_ENDERCHEST_ALL)) {
+            sender.sendMessage(ChatColor.RED + "You do not have permission to access other player's enderchest");
+            return true;
+        }
+
+        // Record the target
+        history = target.getName();
+        openEnderHistory.put(player, history);
+
+        // Create the inventory
+        ISpecialEnderChest chest = OpenInv.enderChests.get(target.getName().toLowerCase());
+        if (chest == null) {
+            chest = InternalAccessor.Instance.newSpecialEnderChest(target, !offline);
+        }
+
+        // Open the inventory
+        player.openInventory(chest.getBukkitInventory());
+
+        return true;
+    }
+}

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

@@ -0,0 +1,126 @@
+/*
+ * 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 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.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;
+    }
+
+    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 (!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;
+        }
+
+        Player player = (Player) sender;
+        boolean offline = false;
+
+        // History management
+        String history = openInvHistory.get(player);
+
+        if (history == null || history == "") {
+            history = player.getName();
+            openInvHistory.put(player, history);
+        }
+
+        // Target selecting
+        Player target;
+
+        String name = "";
+
+        // Read from history if target is not named
+        if (args.length < 1) {
+            name = history;
+        }
+        else {
+            name = args[0];
+        }
+
+        target = this.plugin.getServer().getPlayer(name);
+
+        if (target == null) {
+            if (target == null) {
+                // Try loading the player's data
+                target = OpenInv.playerLoader.loadPlayer(name);
+
+                if (target == null) {
+                    sender.sendMessage(ChatColor.RED + "Player " + name + " not found!");
+                    return true;
+                }
+            }
+        }
+
+        // Permissions checks
+        if (!OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE) && OpenInv.hasPermission(target, Permissions.PERM_EXEMPT)) {
+            sender.sendMessage(ChatColor.RED + target.getDisplayName() + "'s inventory is protected!");
+            return true;
+        }
+
+        // Crosswork check
+        if ((!OpenInv.hasPermission(player, Permissions.PERM_CROSSWORLD) && !OpenInv.hasPermission(player, Permissions.PERM_OVERRIDE)) && target.getWorld() != player.getWorld()) {
+            sender.sendMessage(ChatColor.RED + target.getDisplayName() + " is not in your world!");
+            return true;
+        }
+
+        // Self-open check
+        if (!OpenInv.hasPermission(player, Permissions.PERM_OPENSELF) && target.equals(player)) {
+            sender.sendMessage(ChatColor.RED + "You're not allowed to openinv yourself.");
+            return true;
+        }
+
+        // Record the target
+        history = target.getName();
+        openInvHistory.put(player, history);
+
+        // Create the inventory
+        ISpecialPlayerInventory inv = OpenInv.inventories.get(target.getName().toLowerCase());
+        if (inv == null) {
+            inv = InternalAccessor.Instance.newSpecialPlayerInventory(target, !offline);
+        }
+
+        // Open the inventory
+        player.openInventory(inv.getBukkitInventory());
+
+        return true;
+    }
+}

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

@@ -0,0 +1,77 @@
+/*
+ * 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 SearchInvPluginCommand implements CommandExecutor {
+    public SearchInvPluginCommand() {
+
+    }
+
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (sender instanceof Player) {
+            if (!OpenInv.hasPermission(sender, Permissions.PERM_SEARCH)) {
+                sender.sendMessage(ChatColor.RED + "You do not have permission to access player inventories");
+                return true;
+            }
+        }
+
+        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,57 @@
+/*
+ * 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 SilentChestPluginCommand implements CommandExecutor {
+    public SilentChestPluginCommand(OpenInv plugin) {
+
+    }
+
+    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 (!OpenInv.hasPermission(sender, Permissions.PERM_SILENT)) {
+            sender.sendMessage(ChatColor.RED + "You do not have permission to use silent chest.");
+            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/commands/ToggleOpenInvPluginCommand.java

@@ -0,0 +1,60 @@
+/*
+ * 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.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 ToggleOpenInvPluginCommand implements CommandExecutor {
+
+    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 (!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")) {
+                if (OpenInv.GetPlayerItemOpenInvStatus(player.getName()))
+                    player.sendMessage("OpenInv with " + Material.getMaterial(OpenInv.GetItemOpenInvItem()).toString() + " is ON.");
+                else
+                    player.sendMessage("OpenInv with " + Material.getMaterial(OpenInv.GetItemOpenInvItem()).toString() + " is OFF.");
+            }
+        }
+        if (OpenInv.GetPlayerItemOpenInvStatus(player.getName())) {
+            OpenInv.SetPlayerItemOpenInvStatus(player.getName(), false);
+            player.sendMessage("OpenInv with " + Material.getMaterial(OpenInv.GetItemOpenInvItem()).toString() + " is OFF.");
+        }
+        else {
+            OpenInv.SetPlayerItemOpenInvStatus(player.getName(), true);
+            player.sendMessage("OpenInv with " + Material.getMaterial(OpenInv.GetItemOpenInvItem()).toString() + " is ON.");
+        }
+        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,23 @@
+/*
+ * 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 IPlayerDataManager {
+    public Player loadPlayer(String name);
+}

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_8_R1/AnySilentChest.java

@@ -0,0 +1,119 @@
+/*
+ * 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_8_R1;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.IAnySilentChest;
+
+
+
+
+
+
+//Volatile
+import net.minecraft.server.v1_8_R1.*;
+
+import org.bukkit.craftbukkit.v1_8_R1.entity.*;
+
+public class AnySilentChest implements IAnySilentChest {
+    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 on top
+        if (world.getType(new BlockPosition(x, y + 1, z)).getBlock().c())
+            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 on top
+        if ((Block.getId(world.getType(new BlockPosition(x - 1, y, z)).getBlock()) == id) && (world.getType(new BlockPosition(x - 1, y + 1, z)).getBlock().c()))
+            return true;
+        if ((Block.getId(world.getType(new BlockPosition(x + 1, y, z)).getBlock()) == id) && (world.getType(new BlockPosition(x + 1, y + 1, z)).getBlock().c()))
+            return true;
+        if ((Block.getId(world.getType(new BlockPosition(x, y, z - 1)).getBlock()) == id) && (world.getType(new BlockPosition(x, y + 1, z - 1)).getBlock().c()))
+            return true;
+        if ((Block.getId(world.getType(new BlockPosition(x, y, z + 1)).getBlock()) == id) && (world.getType(new BlockPosition(x, y + 1, z + 1)).getBlock().c()))
+            return true;
+
+        return false;
+    }
+
+    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 = (TileEntityChest) 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)).getBlock().c())
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x - 1, y, z)).getBlock()) == id) && (world.getType(new BlockPosition(x - 1, y + 1, z)).getBlock().c()))
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x + 1, y, z)).getBlock()) == id) && (world.getType(new BlockPosition(x + 1, y + 1, z)).getBlock().c()))
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x, y, z - 1)).getBlock()) == id) && (world.getType(new BlockPosition(x, y + 1, z - 1)).getBlock().c()))
+                return true;
+            if ((Block.getId(world.getType(new BlockPosition(x, y, z + 1)).getBlock()) == id) && (world.getType(new BlockPosition(x, y + 1, z + 1)).getBlock().c()))
+                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_8_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_8_R1;
 
 import java.lang.reflect.Field;
 
@@ -23,13 +23,13 @@ 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 net.minecraft.server.v1_8_R1.*;
+import org.bukkit.craftbukkit.v1_8_R1.inventory.*;
 
-import org.bukkit.craftbukkit.v1_8_R3.inventory.*;
-
-public class InventoryAccess {
+public class InventoryAccess implements IInventoryAccess {
     public boolean check(Inventory inventory, HumanEntity player) {
         IInventory inv = grabInventory(inventory);
         
@@ -53,7 +53,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_8_R1/PlayerDataManager.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2011-2014 lishid.  All rights reserved.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation,  version 3.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.internal.v1_8_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 net.minecraft.server.v1_8_R1.*;
+
+import org.bukkit.craftbukkit.v1_8_R1.*;
+
+public class PlayerDataManager implements IPlayerDataManager {
+    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;
+    }
+}

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

@@ -14,23 +14,23 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.lishid.openinv.internal;
+package com.lishid.openinv.internal.v1_8_R1;
 
-// Volatile
-import net.minecraft.server.v1_8_R3.*;
+//Volatile
+import net.minecraft.server.v1_8_R1.*;
 
 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_8_R1/SpecialEnderChest.java

@@ -0,0 +1,126 @@
+/*
+ * 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_8_R1;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.internal.ISpecialEnderChest;
+
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+
+//Volatile
+import net.minecraft.server.v1_8_R1.*;
+import org.bukkit.craftbukkit.v1_8_R1.entity.*;
+import org.bukkit.craftbukkit.v1_8_R1.inventory.*;
+
+public class SpecialEnderChest extends InventorySubcontainer implements IInventory, ISpecialEnderChest {
+    public List<HumanEntity> transaction = new ArrayList<HumanEntity>();
+    public boolean playerOnline = false;
+    private CraftPlayer owner;
+    private InventoryEnderChest enderChest;
+    private int maxStack = MAX_STACK;
+    private 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);
+    }
+
+    public Inventory getBukkitInventory() {
+        return inventory;
+    }
+
+    public void InventoryRemovalCheck() {
+        owner.saveData();
+        if (transaction.isEmpty() && !playerOnline) {
+            OpenInv.enderChests.remove(owner.getName().toLowerCase());
+        }
+    }
+
+    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;
+        }
+    }
+
+    public void PlayerGoOffline() {
+        playerOnline = false;
+    }
+
+    public ItemStack[] getContents() {
+        return this.items;
+    }
+
+    public void onOpen(CraftHumanEntity who) {
+        transaction.add(who);
+    }
+
+    public void onClose(CraftHumanEntity who) {
+        transaction.remove(who);
+        this.InventoryRemovalCheck();
+    }
+
+    public List<HumanEntity> getViewers() {
+        return transaction;
+    }
+
+    public InventoryHolder getOwner() {
+        return this.owner;
+    }
+
+    public void setMaxStackSize(int size) {
+        maxStack = size;
+    }
+
+    public int getMaxStackSize() {
+        return maxStack;
+    }
+
+    public boolean a(EntityHuman entityhuman) {
+        return true;
+    }
+
+    public void startOpen() {
+
+    }
+
+    public void f() {
+
+    }
+
+    public void update() {
+        enderChest.update();
+    }
+}

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

@@ -14,77 +14,75 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.lishid.openinv.internal;
+package com.lishid.openinv.internal.v1_8_R1;
 
 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 net.minecraft.server.v1_8_R1.*;
+import org.bukkit.craftbukkit.v1_8_R1.entity.*;
+import org.bukkit.craftbukkit.v1_8_R1.inventory.*;
 
-import org.bukkit.craftbukkit.v1_8_R3.entity.*;
-import org.bukkit.craftbukkit.v1_8_R3.inventory.*;
+public class SpecialPlayerInventory extends PlayerInventory implements ISpecialPlayerInventory {
+    CraftPlayer owner;
+    public boolean playerOnline = false;
+    private ItemStack[] extra = new ItemStack[5];
+    private CraftInventory inventory = new CraftInventory(this);
 
-public class SpecialPlayerInventory extends PlayerInventory {
-    private final CraftInventory inventory = new CraftInventory(this);
-    private final ItemStack[] extra = new ItemStack[5];
-    private final CraftPlayer owner;
-    private boolean playerOnline;
-
-    public SpecialPlayerInventory(Player p, boolean online) {
+    public SpecialPlayerInventory(Player p, Boolean online) {
         super(((CraftPlayer) p).getHandle());
-        this.owner = (CraftPlayer) p;
+        this.owner = ((CraftPlayer) p);
+        this.playerOnline = online;
         this.items = player.inventory.items;
         this.armor = player.inventory.armor;
-        this.playerOnline = online;
-        OpenInv.inventories.put(owner.getUniqueId(), this);
+        OpenInv.inventories.put(owner.getName().toLowerCase(), this);
     }
 
+    @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);
+            p.getHandle().inventory.items = this.items;
+            p.getHandle().inventory.armor = this.armor;
             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
     public ItemStack[] getContents() {
         ItemStack[] C = new ItemStack[getSize()];
         System.arraycopy(items, 0, C, 0, items.length);
-        System.arraycopy(armor, 0, C, items.length, armor.length);
+        System.arraycopy(items, 0, C, items.length, armor.length);
         return C;
     }
 
@@ -100,14 +98,16 @@ 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) {
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
@@ -121,14 +121,16 @@ 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) {
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
@@ -139,7 +141,8 @@ public class SpecialPlayerInventory extends PlayerInventory {
                 itemstack = is[i];
                 is[i] = null;
                 return itemstack;
-            } else {
+            }
+            else {
                 itemstack = is[i].a(j);
                 if (is[i].count == 0) {
                     is[i] = null;
@@ -147,7 +150,8 @@ public class SpecialPlayerInventory extends PlayerInventory {
 
                 return itemstack;
             }
-        } else {
+        }
+        else {
             return null;
         }
     }
@@ -159,14 +163,16 @@ 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) {
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
@@ -175,36 +181,39 @@ public class SpecialPlayerInventory extends PlayerInventory {
 
             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) {
+        }
+        else if (is == this.armor) {
             i = getReversedArmorSlotNum(i);
         }
 
         // 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 +238,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 +250,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/com/lishid/openinv/utils/UpdateManager.java

@@ -0,0 +1,34 @@
+package com.lishid.openinv.utils;
+
+import java.io.File;
+
+import com.lishid.openinv.OpenInv;
+import com.lishid.openinv.utils.Updater.UpdateResult;
+
+public class UpdateManager {
+    public Updater updater;
+
+    public void Initialize(OpenInv plugin, File file) {
+        updater = new Updater(plugin, 31432, file);
+
+        // Create task to update
+        plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
+            @Override
+            public void run() {
+                // Check for updates
+                if (OpenInv.GetCheckForUpdates()) {
+                    UpdateResult result = updater.update();
+                    if (result != UpdateResult.NO_UPDATE) {
+                        if (result == UpdateResult.SUCCESS) {
+                            OpenInv.log("Update found! Downloaded new version.");
+                            OpenInv.log("This behaviour can be disabled in the config.yml");
+                        }
+                        else {
+                            OpenInv.log("Update failed, reason: " + result.toString());
+                        }
+                    }
+                }
+            }
+        }, 0, 20 * 60 * 1000); // Update every once a while
+    }
+}

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

@@ -0,0 +1,412 @@
+/*
+ * Updater for Bukkit.
+ *
+ * This class provides the means to safely and easily update a plugin, or check to see if it is updated using dev.bukkit.org
+ */
+
+package com.lishid.openinv.utils;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Enumeration;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.bukkit.plugin.Plugin;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.JSONValue;
+
+/**
+ * Check dev.bukkit.org to find updates for a given plugin, and download the updates if needed.
+ * <p/>
+ * <b>VERY, VERY IMPORTANT</b>: Because there are no standards for adding auto-update toggles in your plugin's config, this system provides NO CHECK WITH YOUR CONFIG to make sure the user has allowed
+ * auto-updating. <br>
+ * It is a <b>BUKKIT POLICY</b> that you include a boolean value in your config that prevents the auto-updater from running <b>AT ALL</b>. <br>
+ * If you fail to include this option in your config, your plugin will be <b>REJECTED</b> when you attempt to submit it to dev.bukkit.org.
+ * <p/>
+ * An example of a good configuration option would be something similar to 'auto-update: true' - if this value is set to false you may NOT run the auto-updater. <br>
+ * If you are unsure about these rules, please read the plugin submission guidelines: http://goo.gl/8iU5l
+ * 
+ * @author Gravity
+ * @version 2.0
+ */
+
+public class Updater {
+
+    private Plugin plugin;
+    private String versionName;
+    private String versionLink;
+    @SuppressWarnings("unused")
+    private String versionType;
+    @SuppressWarnings("unused")
+    private String versionGameVersion;
+
+    private boolean announce; // Whether to announce file downloads
+
+    private URL url; // Connecting to RSS
+    private File file; // The plugin's file
+
+    private int id = 31432; // Project's Curse ID
+    // SEE https://dev.bukkit.org/home/servermods-apikey/
+    private String apiKey = null; // BukkitDev ServerMods API key
+    private static final String TITLE_VALUE = "name"; // Gets remote file's title
+    private static final String LINK_VALUE = "downloadUrl"; // Gets remote file's download link
+    private static final String TYPE_VALUE = "releaseType"; // Gets remote file's release type
+    private static final String VERSION_VALUE = "gameVersion"; // Gets remote file's build version
+    private static final String QUERY = "/servermods/files?projectIds="; // Path to GET
+    private static final String HOST = "https://api.curseforge.com"; // Slugs will be appended to this to get to the project's RSS feed
+
+    private static final String[] NO_UPDATE_TAG = { "-DEV", "-PRE", "-SNAPSHOT" }; // If the version number contains one of these, don't update.
+    private static final int BYTE_SIZE = 1024; // Used for downloading files
+    private String updateFolder;// The folder that downloads will be placed in
+    private Updater.UpdateResult result = Updater.UpdateResult.SUCCESS; // Used for determining the outcome of the update process
+
+    /**
+     * Gives the dev the result of the update process. Can be obtained by called getResult().
+     */
+    public enum UpdateResult {
+        /**
+         * The updater found an update, and has readied it to be loaded the next time the server restarts/reloads.
+         */
+        SUCCESS,
+        /**
+         * The updater did not find an update, and nothing was downloaded.
+         */
+        NO_UPDATE,
+        /**
+         * The server administrator has disabled the updating system
+         */
+        DISABLED,
+        /**
+         * The updater found an update, but was unable to download it.
+         */
+        FAIL_DOWNLOAD,
+        /**
+         * For some reason, the updater was unable to contact dev.bukkit.org to download the file.
+         */
+        FAIL_DBO,
+        /**
+         * When running the version check, the file on DBO did not contain the a version in the format 'vVersion' such as 'v1.0'.
+         */
+        FAIL_NOVERSION,
+        /**
+         * The id provided by the plugin running the updater was invalid and doesn't exist on DBO.
+         */
+        FAIL_BADID,
+        /**
+         * The server administrator has improperly configured their API key in the configuration
+         */
+        FAIL_APIKEY,
+        /**
+         * The updater found an update, but because of the UpdateType being set to NO_DOWNLOAD, it wasn't downloaded.
+         */
+        UPDATE_AVAILABLE
+    }
+
+    /**
+     * Initialize the updater
+     * 
+     * @param plugin The plugin that is checking for an update.
+     * @param id The dev.bukkit.org id of the project
+     * @param file The file that the plugin is running from, get this by doing this.getFile() from within your main class.
+     */
+    public Updater(Plugin plugin, int id, File file) {
+        this.plugin = plugin;
+        this.file = file;
+        this.id = id;
+        this.updateFolder = plugin.getServer().getUpdateFolder();
+
+        try {
+            this.url = new URL(Updater.HOST + Updater.QUERY + id);
+        }
+        catch (final MalformedURLException e) {
+            plugin.getLogger().severe("The project ID provided for updating, " + id + " is invalid.");
+            this.result = UpdateResult.FAIL_BADID;
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Save an update from dev.bukkit.org into the server's update folder.
+     */
+    private void saveFile(File folder, String file, String u) {
+        if (!folder.exists()) {
+            folder.mkdir();
+        }
+        BufferedInputStream in = null;
+        FileOutputStream fout = null;
+        try {
+            // Download the file
+            final URL url = new URL(u);
+            final int fileLength = url.openConnection().getContentLength();
+            in = new BufferedInputStream(url.openStream());
+            fout = new FileOutputStream(folder.getAbsolutePath() + "/" + file);
+
+            final byte[] data = new byte[Updater.BYTE_SIZE];
+            int count;
+            if (this.announce) {
+                this.plugin.getLogger().info("About to download a new update: " + this.versionName);
+            }
+            long downloaded = 0;
+            while ((count = in.read(data, 0, Updater.BYTE_SIZE)) != -1) {
+                downloaded += count;
+                fout.write(data, 0, count);
+                final int percent = (int) ((downloaded * 100) / fileLength);
+                if (this.announce && ((percent % 10) == 0)) {
+                    this.plugin.getLogger().info("Downloading update: " + percent + "% of " + fileLength + " bytes.");
+                }
+            }
+            // Just a quick check to make sure we didn't leave any files from last time...
+            for (final File xFile : new File(this.plugin.getDataFolder().getParent(), this.updateFolder).listFiles()) {
+                if (xFile.getName().endsWith(".zip")) {
+                    xFile.delete();
+                }
+            }
+            // Check to see if it's a zip file, if it is, unzip it.
+            final File dFile = new File(folder.getAbsolutePath() + "/" + file);
+            if (dFile.getName().endsWith(".zip")) {
+                // Unzip
+                this.unzip(dFile.getCanonicalPath());
+            }
+            if (this.announce) {
+                this.plugin.getLogger().info("Finished updating.");
+            }
+        }
+        catch (final Exception ex) {
+            this.plugin.getLogger().warning("The auto-updater tried to download a new update, but was unsuccessful.");
+            this.result = Updater.UpdateResult.FAIL_DOWNLOAD;
+        }
+        finally {
+            try {
+                if (in != null) {
+                    in.close();
+                }
+                if (fout != null) {
+                    fout.close();
+                }
+            }
+            catch (final Exception ex) {}
+        }
+    }
+
+    /**
+     * Part of Zip-File-Extractor, modified by Gravity for use with Bukkit
+     */
+    private void unzip(String file) {
+        try {
+            final File fSourceZip = new File(file);
+            final String zipPath = file.substring(0, file.length() - 4);
+            ZipFile zipFile = new ZipFile(fSourceZip);
+            Enumeration<? extends ZipEntry> e = zipFile.entries();
+            while (e.hasMoreElements()) {
+                ZipEntry entry = e.nextElement();
+                File destinationFilePath = new File(zipPath, entry.getName());
+                destinationFilePath.getParentFile().mkdirs();
+                if (entry.isDirectory()) {
+                    continue;
+                }
+                else {
+                    final BufferedInputStream bis = new BufferedInputStream(zipFile.getInputStream(entry));
+                    int b;
+                    final byte buffer[] = new byte[Updater.BYTE_SIZE];
+                    final FileOutputStream fos = new FileOutputStream(destinationFilePath);
+                    final BufferedOutputStream bos = new BufferedOutputStream(fos, Updater.BYTE_SIZE);
+                    while ((b = bis.read(buffer, 0, Updater.BYTE_SIZE)) != -1) {
+                        bos.write(buffer, 0, b);
+                    }
+                    bos.flush();
+                    bos.close();
+                    bis.close();
+                    final String name = destinationFilePath.getName();
+                    if (name.endsWith(".jar") && this.pluginFile(name)) {
+                        destinationFilePath.renameTo(new File(this.plugin.getDataFolder().getParent(), this.updateFolder + "/" + name));
+                    }
+                }
+                entry = null;
+                destinationFilePath = null;
+            }
+            e = null;
+            zipFile.close();
+            zipFile = null;
+
+            // Move any plugin data folders that were included to the right place, Bukkit won't do this for us.
+            for (final File dFile : new File(zipPath).listFiles()) {
+                if (dFile.isDirectory()) {
+                    if (this.pluginFile(dFile.getName())) {
+                        final File oFile = new File(this.plugin.getDataFolder().getParent(), dFile.getName()); // Get current dir
+                        final File[] contents = oFile.listFiles(); // List of existing files in the current dir
+                        for (final File cFile : dFile.listFiles()) // Loop through all the files in the new dir
+                        {
+                            boolean found = false;
+                            for (final File xFile : contents) // Loop through contents to see if it exists
+                            {
+                                if (xFile.getName().equals(cFile.getName())) {
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                // Move the new file into the current dir
+                                cFile.renameTo(new File(oFile.getCanonicalFile() + "/" + cFile.getName()));
+                            }
+                            else {
+                                // This file already exists, so we don't need it anymore.
+                                cFile.delete();
+                            }
+                        }
+                    }
+                }
+                dFile.delete();
+            }
+            new File(zipPath).delete();
+            fSourceZip.delete();
+        }
+        catch (final IOException ex) {
+            this.plugin.getLogger().warning("The auto-updater tried to unzip a new update file, but was unsuccessful.");
+            this.result = Updater.UpdateResult.FAIL_DOWNLOAD;
+            ex.printStackTrace();
+        }
+        new File(file).delete();
+    }
+
+    /**
+     * Check if the name of a jar is one of the plugins currently installed, used for extracting the correct files out of a zip.
+     */
+    private boolean pluginFile(String name) {
+        for (final File file : new File("plugins").listFiles()) {
+            if (file.getName().equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check to see if the program should continue by evaluation whether the plugin is already updated, or shouldn't be updated
+     */
+    private boolean versionCheck(String title) {
+        final String version = this.plugin.getDescription().getVersion();
+        if (title.split(" ").length == 2) {
+            final String remoteVersion = title.split(" ")[1].split(" ")[0]; // Get the newest file's version number
+
+            if (this.hasTag(version) || version.equalsIgnoreCase(remoteVersion) || !isNewer(version, remoteVersion)) {
+                // We already have the latest version, or this build is tagged for no-update
+                this.result = Updater.UpdateResult.NO_UPDATE;
+                return false;
+            }
+        }
+        else {
+            this.plugin.getLogger().warning("File versions should follow the format 'PluginName VERSION'");
+            this.result = Updater.UpdateResult.FAIL_NOVERSION;
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Evaluate whether the version number is marked showing that it should not be updated by this program
+     */
+    private boolean hasTag(String version) {
+        for (final String string : Updater.NO_UPDATE_TAG) {
+            if (version.contains(string)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean read() {
+        try {
+            final URLConnection conn = this.url.openConnection();
+            conn.setConnectTimeout(5000);
+
+            if (this.apiKey != null) {
+                conn.addRequestProperty("X-API-Key", this.apiKey);
+            }
+            conn.addRequestProperty("User-Agent", "Updater");
+
+            conn.setDoOutput(true);
+
+            final BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+            final String response = reader.readLine();
+
+            final JSONArray array = (JSONArray) JSONValue.parse(response);
+
+            if (array.size() == 0) {
+                this.plugin.getLogger().warning("The updater could not find any files for the project id " + this.id);
+                this.result = UpdateResult.FAIL_BADID;
+                return false;
+            }
+
+            this.versionName = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.TITLE_VALUE);
+            this.versionLink = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.LINK_VALUE);
+            this.versionType = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.TYPE_VALUE);
+            this.versionGameVersion = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.VERSION_VALUE);
+
+            return true;
+        }
+        catch (final IOException e) {
+            if (e.getMessage().contains("HTTP response code: 403")) {
+                this.plugin.getLogger().warning("dev.bukkit.org rejected the API key provided in plugins/Updater/config.yml");
+                this.plugin.getLogger().warning("Please double-check your configuration to ensure it is correct.");
+                this.result = UpdateResult.FAIL_APIKEY;
+            }
+            else {
+                this.plugin.getLogger().warning("The updater could not contact curse for updating.");
+                this.result = UpdateResult.FAIL_DBO;
+            }
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    private static boolean isNewer(String oldVers, String newVers) {
+        String s1 = normalisedVersion(oldVers);
+        String s2 = normalisedVersion(newVers);
+        int cmp = s1.compareTo(s2);
+        return cmp < 0;
+    }
+
+    public static String normalisedVersion(String version) {
+        return normalisedVersion(version, ".", 3);
+    }
+
+    public static String normalisedVersion(String version, String sep, int maxWidth) {
+        String[] split = Pattern.compile(sep, Pattern.LITERAL).split(version);
+        StringBuilder sb = new StringBuilder();
+        for (String s : split) {
+            sb.append(String.format("%" + maxWidth + 's', s));
+        }
+        return sb.toString();
+    }
+
+    public UpdateResult update() {
+        if (Updater.this.url != null) {
+            // Obtain the results of the project's file feed
+            if (Updater.this.read()) {
+                if (Updater.this.versionCheck(Updater.this.versionName)) {
+                    if (Updater.this.versionLink != null) {
+                        String name = Updater.this.file.getName();
+                        // If it's a zip file, it shouldn't be downloaded as the plugin's name
+                        if (Updater.this.versionLink.endsWith(".zip")) {
+                            final String[] split = Updater.this.versionLink.split("/");
+                            name = split[split.length - 1];
+                        }
+                        Updater.this.saveFile(new File(Updater.this.plugin.getDataFolder().getParent(), Updater.this.updateFolder), name, Updater.this.versionLink);
+                    }
+                }
+            }
+        }
+        return this.result;
+    }
+}

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/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,38 @@
+name: OpenInv
+main: com.lishid.openinv.OpenInv
+version: 2.2.5
+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: Open a player's inventory
+    usage: |
+           /<command> - Open last person's inventory
+           /<command> <Player> - Open a player's inventory
+  openender:
+    aliases: [oe]
+    description: Opens the enderchest of a player
+    usage: |
+           /<command> <Player> - Opens a player's enderchest
+  searchinv:
+    aliases: [si]
+    description: Search and list players having a specific item
+    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: Toggle item openinv function
+    usage: |
+           /<command> [Check] - Checks whether item openinv is enabled
+  silentchest:
+    aliases: [sc, silent]
+    description: Toggle 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
+  anychest:
+    aliases: [ac]
+    description: Toggle anychest function, which allows opening of blocked chests.
+    usage: |
+           /<command> [Check] - Checks whether anychest is enabled