Convert to a more user-friendly Maven setup

Mostly based on Mbaxter's AbstractionExamplePlugin
Compiling OpenInv for a specific version is very easy - just compile the correct module.
Compiling for a set of versions is slightly more complex. You'll need to use a profile for the versions you want to compile. Provided profiles are latest, modern - versions 1.7.10+, and all. For more information, check out the Maven guide http://maven.apache.org/guides/introduction/introduction-to-profiles.html

This commit doesn't change anything with the plugin itself, but it makes it loads easier for people to maintain and compile their own version without destroying backwards compatibility.

OpenInvPlugin/pom.xml

@@ -0,0 +1,34 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>com.lishid</groupId>
+    <artifactId>openinvparent</artifactId>
+    <version>1.0-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>openinvplugin</artifactId>
+  <name>OpenInvPlugin</name>
+
+  <repositories>
+    <repository>
+      <id>spigot-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.10.2-R0.1-SNAPSHOT</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.lishid</groupId>
+      <artifactId>openinvcore</artifactId>
+      <version>1.0-SNAPSHOT</version>
+    </dependency>
+  </dependencies>
+</project>

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

@@ -0,0 +1,455 @@
+/*
+ * 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.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import com.lishid.openinv.commands.AnyChestPluginCommand;
+import com.lishid.openinv.commands.OpenEnderPluginCommand;
+import com.lishid.openinv.commands.OpenInvPluginCommand;
+import com.lishid.openinv.commands.SearchInvPluginCommand;
+import com.lishid.openinv.commands.SilentChestPluginCommand;
+import com.lishid.openinv.internal.IAnySilentChest;
+import com.lishid.openinv.internal.IInventoryAccess;
+import com.lishid.openinv.internal.IPlayerDataManager;
+import com.lishid.openinv.internal.ISpecialEnderChest;
+import com.lishid.openinv.internal.ISpecialPlayerInventory;
+import com.lishid.openinv.internal.InternalAccessor;
+import com.lishid.openinv.util.Cache;
+import com.lishid.openinv.util.Function;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.permissions.Permissible;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+
+/**
+ * Open other player's inventory
+ * 
+ * @author lishid
+ */
+public class OpenInv extends JavaPlugin {
+
+    private final Map<String, ISpecialPlayerInventory> inventories = new HashMap<String, ISpecialPlayerInventory>();
+    private final Map<String, ISpecialEnderChest> enderChests = new HashMap<String, ISpecialEnderChest>();
+    private final Cache<String, Player> playerCache = new Cache<String, Player>(300000L,
+            new Function<Player>() {
+                @Override
+                public boolean run(Player value) {
+                    String key = playerLoader.getPlayerDataID(value);
+                    return inventories.containsKey(key) && inventories.get(key).isInUse()
+                            || enderChests.containsKey(key) && enderChests.get(key).isInUse();
+                }
+            },
+            new Function<Player>() {
+                @Override
+                public boolean run(Player value) {
+                    String key = playerLoader.getPlayerDataID(value);
+
+                    // Check if inventory is stored, and if it is, remove it and eject all viewers
+                    if (inventories.containsKey(key)) {
+                        Inventory inv = inventories.remove(key).getBukkitInventory();
+                        for (HumanEntity entity : inv.getViewers()) {
+                            entity.closeInventory();
+                        }
+                    }
+
+                    // Check if ender chest is stored, and if it is, remove it and eject all viewers
+                    if (enderChests.containsKey(key)) {
+                        Inventory inv = enderChests.remove(key).getBukkitInventory();
+                        for (HumanEntity entity : inv.getViewers()) {
+                            entity.closeInventory();
+                        }
+                    }
+
+                    if (!OpenInv.this.disableSaving() && !value.isOnline()) {
+                        value.saveData();
+                    }
+                    return true;
+                }
+            });
+
+    private InternalAccessor accessor;
+    private IPlayerDataManager playerLoader;
+    private IInventoryAccess inventoryAccess;
+    private IAnySilentChest anySilentChest;
+
+    @Override
+    public void onEnable() {
+        // Get plugin manager
+        PluginManager pm = getServer().getPluginManager();
+
+        accessor = new InternalAccessor(this);
+        // Version check
+        if (!accessor.initialize(getServer())) {
+            getLogger().info("Your version of CraftBukkit is not supported.");
+            getLogger().info("Please look for an updated version of OpenInv.");
+            pm.disablePlugin(this);
+            return;
+        }
+
+        playerLoader = accessor.newPlayerDataManager();
+        inventoryAccess = accessor.newInventoryAccess();
+        anySilentChest = accessor.newAnySilentChest();
+
+        FileConfiguration config = getConfig();
+        boolean dirtyConfig = false;
+        if (!config.isBoolean("NotifySilentChest")) {
+            config.set("NotifySilentChest", true);
+            dirtyConfig = true;
+        }
+        if (!config.isBoolean("NotifyAnyChest")) {
+            config.set("NotifyAnyChest", true);
+            dirtyConfig = true;
+        }
+        if (!config.isBoolean("DisableSaving")) {
+            config.set("DisableSaving", false);
+            dirtyConfig = true;
+        }
+        config.addDefault("NotifySilentChest", true);
+        config.addDefault("NotifyAnyChest", true);
+        config.addDefault("DisableSaving", false);
+        config.options().copyDefaults(true);
+        if (dirtyConfig) {
+            saveConfig();
+        }
+
+        pm.registerEvents(new OpenInvPlayerListener(this), this);
+        pm.registerEvents(new OpenInvInventoryListener(this), this);
+
+        getCommand("openinv").setExecutor(new OpenInvPluginCommand(this));
+        getCommand("searchinv").setExecutor(new SearchInvPluginCommand());
+        getCommand("silentchest").setExecutor(new SilentChestPluginCommand(this));
+        getCommand("anychest").setExecutor(new AnyChestPluginCommand(this));
+        getCommand("openender").setExecutor(new OpenEnderPluginCommand(this));
+
+    }
+
+    @Override
+    public void onDisable() {
+
+        if (this.disableSaving()) {
+            return;
+        }
+
+        this.playerCache.invalidateAll();
+    }
+
+    public IInventoryAccess getInventoryAccess() {
+        return this.inventoryAccess;
+    }
+
+    public IAnySilentChest getAnySilentChest() {
+        return this.anySilentChest;
+    }
+
+    public ISpecialPlayerInventory getInventoryFor(Player player, boolean online) {
+        String id = playerLoader.getPlayerDataID(player);
+        if (inventories.containsKey(id)) {
+            return inventories.get(id);
+        }
+        ISpecialPlayerInventory inv = accessor.newSpecialPlayerInventory(player, online);
+        inventories.put(id, inv);
+        playerCache.put(id, player);
+        return inv;
+    }
+
+    public ISpecialEnderChest getEnderChestFor(Player player, boolean online) {
+        String id = playerLoader.getPlayerDataID(player);
+        if (enderChests.containsKey(id)) {
+            return enderChests.get(id);
+        }
+        ISpecialEnderChest inv = accessor.newSpecialEnderChest(player, online);
+        enderChests.put(id, inv);
+        playerCache.put(id, player);
+        return inv;
+    }
+
+    /**
+     * Unload a cached Player's data.
+     * 
+     * @param player the OfflinePlayer to unload
+     */
+    public void unload(OfflinePlayer player) {
+        this.playerCache.invalidate(this.playerLoader.getPlayerDataID(player));
+    }
+
+    public boolean disableSaving() {
+        return getConfig().getBoolean("DisableSaving", false);
+    }
+
+    public boolean notifySilentChest() {
+        return getConfig().getBoolean("NotifySilentChest", true);
+    }
+
+    public boolean notifyAnyChest() {
+        return getConfig().getBoolean("NotifyAnyChest", true);
+    }
+
+    public boolean getPlayerSilentChestStatus(OfflinePlayer player) {
+        return getConfig().getBoolean("SilentChest." + playerLoader.getPlayerDataID(player) + ".toggle", false);
+    }
+
+    public void setPlayerSilentChestStatus(OfflinePlayer player, boolean status) {
+        getConfig().set("SilentChest." + playerLoader.getPlayerDataID(player) + ".toggle", status);
+        saveConfig();
+    }
+
+    public boolean getPlayerAnyChestStatus(OfflinePlayer player) {
+        return getConfig().getBoolean("AnyChest." + playerLoader.getPlayerDataID(player) + ".toggle", true);
+    }
+
+    public void setPlayerAnyChestStatus(OfflinePlayer player, boolean status) {
+        getConfig().set("AnyChest." + playerLoader.getPlayerDataID(player) + ".toggle", status);
+        saveConfig();
+    }
+
+    /**
+     * Get an OfflinePlayer by name.
+     * 
+     * @param name the name of the Player
+     * @return the OfflinePlayer, or null if no players have ever logged in
+     */
+    public OfflinePlayer matchPlayer(String name) {
+
+        // Warn if called on the main thread - if we resort to searching offline players, this may take several seconds.
+        if (getServer().isPrimaryThread()) {
+            getLogger().warning("Call to OpenInv#matchPlayer made on the main thread!");
+            getLogger().warning("This can cause the server to hang, potentially severely.");
+            getLogger().warning("Trace:");
+            for (StackTraceElement element : new Throwable().fillInStackTrace().getStackTrace()) {
+                getLogger().warning(element.toString());
+            }
+        }
+
+        // Ensure name is valid if server is in online mode to avoid unnecessary searching
+        if (getServer().getOnlineMode() && !name.matches("[a-zA-Z0-9_]{3,16}")) {
+            return null;
+        }
+
+        OfflinePlayer player = getServer().getPlayerExact(name);
+
+        if (player != null) {
+            return player;
+        }
+
+        player = getServer().getOfflinePlayer(name);
+
+        /*
+         * Compatibility: Pre-UUID, getOfflinePlayer always returns an OfflinePlayer. Post-UUID,
+         * getOfflinePlayer will return null if no matching player is found. To preserve
+         * compatibility, only return the player if they have played before. Ignoring current online
+         * status is fine, they'd have been found by getPlayerExact otherwise.
+         */
+        if (player != null && player.hasPlayedBefore()) {
+            return player;
+        }
+
+        player = getServer().getPlayer(name);
+
+        if (player != null) {
+            return player;
+        }
+
+        int bestMatch = Integer.MAX_VALUE;
+        for (OfflinePlayer offline : getServer().getOfflinePlayers()) {
+            if (offline.getName() == null) {
+                // Loaded by UUID only, name has never been looked up.
+                continue;
+            }
+
+            // Compatibility: Lang3 is only bundled with 1.8+
+            int currentMatch = org.apache.commons.lang.StringUtils.getLevenshteinDistance(name, offline.getName());
+
+            if (currentMatch == 0) {
+                return offline;
+            }
+
+            if (currentMatch < bestMatch) {
+                bestMatch = currentMatch;
+                player = offline;
+            }
+        }
+
+        // Only null if no players have played ever, otherwise even the worst match will do.
+        return player;
+    }
+
+    /**
+     * Load a Player from an OfflinePlayer.
+     * 
+     * @param offline the OfflinePlayer to load a Player for
+     * @return the Player
+     */
+    public Player loadPlayer(final OfflinePlayer offline) {
+
+        if (offline == null) {
+            return null;
+        }
+
+        String key = this.playerLoader.getPlayerDataID(offline);
+        if (this.playerCache.containsKey(key)) {
+            return this.playerCache.get(key);
+        }
+
+        Player loaded;
+
+        if (offline.isOnline()) {
+            loaded = offline.getPlayer();
+            this.playerCache.put(key, loaded);
+            return loaded;
+        }
+
+        if (Bukkit.isPrimaryThread()) {
+            return this.playerLoader.loadPlayer(offline);
+        }
+
+        Future<Player> future = Bukkit.getScheduler().callSyncMethod(this,
+                new Callable<Player>() {
+                    @Override
+                    public Player call() throws Exception {
+                        return playerLoader.loadPlayer(offline);
+                    }
+                });
+
+        int ticks = 0;
+        while (!future.isDone() && !future.isCancelled() && ticks < 10) {
+            ++ticks;
+            try {
+                Thread.sleep(50L);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                return null;
+            }
+        }
+
+        if (!future.isDone() || future.isCancelled()) {
+            return null;
+        }
+
+        try {
+            loaded = future.get();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+            return null;
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+            return null;
+        }
+
+        if (loaded != null) {
+            this.playerCache.put(key, loaded);
+        }
+
+        return loaded;
+    }
+
+    /**
+     * Method for handling a Player coming online.
+     * 
+     * @param player
+     */
+    public void setPlayerOnline(final Player player) {
+
+        String key = this.playerLoader.getPlayerDataID(player);
+
+        // Check if the player is cached. If not, neither of their inventories is open.
+        if (!this.playerCache.containsKey(key)) {
+            return;
+        }
+
+        this.playerCache.put(key, player);
+
+        if (this.inventories.containsKey(key)) {
+            this.inventories.get(key).setPlayerOnline(player);
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    if (player.isOnline()) {
+                        player.updateInventory();
+                    }
+                }
+            }.runTask(this);
+        }
+
+        if (this.enderChests.containsKey(key)) {
+            this.enderChests.get(key).setPlayerOnline(player);
+        }
+    }
+
+    /**
+     * Method for handling a Player going offline.
+     * 
+     * @param player
+     */
+    public void setPlayerOffline(final Player player) {
+
+        String key = this.playerLoader.getPlayerDataID(player);
+
+        // Check if the player is cached. If not, neither of their inventories is open.
+        if (!this.playerCache.containsKey(key)) {
+            return;
+        }
+
+        if (this.inventories.containsKey(key)) {
+            this.inventories.get(key).setPlayerOffline();
+        }
+
+        if (this.enderChests.containsKey(key)) {
+            this.enderChests.get(key).setPlayerOffline();
+        }
+    }
+
+    public static void ShowHelp(Player player) {
+        // TODO: Do not show commands players lack permissions for
+        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 + "/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);
+    }
+
+}

OpenInvPlugin/src/main/java/com/lishid/openinv/OpenInvInventoryListener.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2011-2014 lishid.  All rights reserved.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation,  version 3.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+
+public class OpenInvInventoryListener implements Listener {
+
+    private final OpenInv plugin;
+
+    public OpenInvInventoryListener(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (!plugin.getInventoryAccess().check(event.getInventory(), event.getWhoClicked())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void onInventoryDrag(InventoryDragEvent event) {
+        if (!plugin.getInventoryAccess().check(event.getInventory(), event.getWhoClicked())) {
+            event.setCancelled(true);
+        }
+    }
+}

OpenInvPlugin/src/main/java/com/lishid/openinv/OpenInvPlayerListener.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;
+
+import org.bukkit.ChatColor;
+import org.bukkit.block.Chest;
+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;
+
+public class OpenInvPlayerListener implements Listener {
+
+    private final OpenInv plugin;
+
+    public OpenInvPlayerListener(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerJoin(final PlayerJoinEvent event) {
+        plugin.setPlayerOnline(event.getPlayer());
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        plugin.setPlayerOffline(event.getPlayer());
+    }
+
+    @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) && plugin.getPlayerSilentChestStatus(player)) {
+                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) && plugin.getPlayerSilentChestStatus(player)) {
+                silentchest = true;
+            }
+
+            if (OpenInv.hasPermission(player, Permissions.PERM_ANYCHEST) && plugin.getPlayerAnyChestStatus(player)) {
+                try {
+                    anychest = plugin.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 (!plugin.getAnySilentChest().activateChest(player, anychest, silentchest, x, y, z)) {
+                    if (silentchest && plugin.notifySilentChest()) {
+                        player.sendMessage("You are opening a chest silently.");
+                    }
+                    if (anychest && plugin.notifyAnyChest()) {
+                        player.sendMessage("You are opening a blocked chest.");
+                    }
+                    event.setCancelled(true);
+                }
+            }
+        }
+    }
+
+}

OpenInvPlugin/src/main/java/com/lishid/openinv/Permissions.java

@@ -0,0 +1,16 @@
+package com.lishid.openinv;
+
+public class Permissions {
+    public static final String PERM_OPENINV = "OpenInv.openinv";
+    public static final String PERM_OVERRIDE = "OpenInv.override";
+    public static final String PERM_EXEMPT = "OpenInv.exempt";
+    public static final String PERM_CROSSWORLD = "OpenInv.crossworld";
+    public static final String PERM_SILENT = "OpenInv.silent";
+    public static final String PERM_ANYCHEST = "OpenInv.anychest";
+    public static final String PERM_ENDERCHEST = "OpenInv.openender";
+    public static final String PERM_ENDERCHEST_ALL = "OpenInv.openenderall";
+    public static final String PERM_SEARCH = "OpenInv.search";
+    public static final String PERM_EDITINV = "OpenInv.editinv";
+    public static final String PERM_EDITENDER = "OpenInv.editender";
+    public static final String PERM_OPENSELF = "OpenInv.openself";
+}

OpenInvPlugin/src/main/java/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;
+
+public class AnyChestPluginCommand implements CommandExecutor {
+
+    private final OpenInv plugin;
+
+    public AnyChestPluginCommand(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;
+        }
+
+        Player player = (Player) sender;
+
+        if (args.length > 0) {
+            if (args[0].equalsIgnoreCase("check")) {
+                if (plugin.getPlayerAnyChestStatus(player))
+                    sender.sendMessage("AnyChest is ON.");
+                else
+                    sender.sendMessage("AnyChest is OFF.");
+            }
+        }
+
+        plugin.setPlayerAnyChestStatus(player, !plugin.getPlayerAnyChestStatus(player));
+        sender.sendMessage("AnyChest is now " + (plugin.getPlayerAnyChestStatus(player) ? "On" : "Off") + ".");
+
+        return true;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2011-2014 lishid.  All rights reserved.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation,  version 3.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lishid.openinv.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class SearchInvPluginCommand implements CommandExecutor {
+    public SearchInvPluginCommand() {
+
+    }
+
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        String PlayerList = "";
+
+        Material material = null;
+        int count = 1;
+
+        if (args.length >= 1) {
+            String[] gData = null;
+            gData = args[0].split(":");
+            material = Material.matchMaterial(gData[0]);
+        }
+        if (args.length >= 2) {
+            try {
+                count = Integer.parseInt(args[1]);
+            }
+            catch (NumberFormatException ex) {
+                sender.sendMessage(ChatColor.RED + "'" + args[1] + "' is not a number!");
+                return false;
+            }
+        }
+
+        if (material == null) {
+            sender.sendMessage(ChatColor.RED + "Unknown item");
+            return false;
+        }
+
+        for (Player templayer : Bukkit.getServer().getOnlinePlayers()) {
+            if (templayer.getInventory().contains(material, count)) {
+                PlayerList += templayer.getName() + "  ";
+            }
+        }
+
+        sender.sendMessage("Players with the item " + material.toString() + ":  " + PlayerList);
+        return true;
+    }
+}

OpenInvPlugin/src/main/java/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;
+
+public class SilentChestPluginCommand implements CommandExecutor {
+
+    private final OpenInv plugin;
+
+    public SilentChestPluginCommand(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;
+        }
+
+        Player player = (Player) sender;
+
+        if (args.length > 0) {
+            if (args[0].equalsIgnoreCase("check")) {
+                if (plugin.getPlayerSilentChestStatus(player))
+                    sender.sendMessage("SilentChest is ON.");
+                else
+                    sender.sendMessage("SilentChest is OFF.");
+            }
+        }
+
+        plugin.setPlayerSilentChestStatus(player, !plugin.getPlayerSilentChestStatus(player));
+        sender.sendMessage("SilentChest is now " + (plugin.getPlayerSilentChestStatus(player) ? "On" : "Off") + ".");
+
+        return true;
+    }
+}

OpenInvPlugin/src/main/java/com/lishid/openinv/internal/InternalAccessor.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.internal;
+
+import com.lishid.openinv.OpenInv;
+
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+public class InternalAccessor {
+
+    private final OpenInv plugin;
+
+    private String version;
+
+    public InternalAccessor(OpenInv plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Check if the current server version is supported, and, if it is, prepare to load version-specific code.
+     * 
+     * @param server the Server
+     * 
+     * @return true if supported
+     */
+    public boolean initialize(Server server) {
+        String packageName = server.getClass().getPackage().getName();
+        version = packageName.substring(packageName.lastIndexOf('.') + 1);
+
+        try {
+            Class.forName("com.lishid.openinv.internal." + version + ".AnySilentChest");
+            return true;
+        }
+        catch (Exception e) {
+            return false;
+        }
+    }
+
+    private void printErrorMessage() {
+        plugin.getLogger().warning("OpenInv encountered an error with the CraftBukkit version \"" + 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) {
+            printErrorMessage();
+            e.printStackTrace();
+        }
+
+        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) {
+            printErrorMessage();
+            e.printStackTrace();
+        }
+
+        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) {
+            printErrorMessage();
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+}

OpenInvPlugin/src/main/java/com/lishid/openinv/util/Cache.java

@@ -0,0 +1,160 @@
+package com.lishid.openinv.util;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import com.google.common.collect.Multimap;
+import com.google.common.collect.TreeMultimap;
+
+/**
+ * A minimal time-based cache implementation backed by a HashMap and TreeMultimap.
+ * 
+ * @author Jikoo
+ */
+public class Cache<K, V> {
+
+    private final Map<K, V> internal;
+    private final Multimap<Long, K> expiry;
+    private final long retention;
+    private final Function<V> inUseCheck, postRemoval;
+
+    /**
+     * Constructs a Cache with the specified retention duration, in use function, and post-removal function.
+     * 
+     * @param retention duration after which keys are automatically invalidated if not in use
+     * @param inUseCheck Function used to check if a key is considered in use
+     * @param postRemoval Function used to perform any operations required when a key is invalidated
+     */
+    public Cache(long retention, Function<V> inUseCheck, Function<V> postRemoval) {
+        this.internal = new HashMap<K, V>();
+
+        this.expiry = TreeMultimap.create(new Comparator<Long>() {
+                    @Override
+                    public int compare(Long long1, Long long2) {
+                        return long1.compareTo(long2);
+                    }
+                },
+                new Comparator<K>() {
+                    @Override
+                    public int compare(K k1, K k2) {
+                        return 0;
+                    }
+                });
+
+        this.retention = retention;
+        this.inUseCheck = inUseCheck;
+        this.postRemoval = postRemoval;
+    }
+
+    /**
+     * Set a key and value pair. Keys are unique. Using an existing key will cause the old value to
+     * be overwritten and the expiration timer to be reset.
+     * 
+     * @param key key with which the specified value is to be associated
+     * @param value value to be associated with the specified key
+     */
+    public void put(K key, V value) {
+        // Invalidate key - runs lazy check and ensures value won't be cleaned up early
+        invalidate(key);
+
+        internal.put(key, value);
+        expiry.put(System.currentTimeMillis() + retention, key);
+    }
+
+    /**
+     * Returns the value to which the specified key is mapped, or null if no value is mapped for the key.
+     * 
+     * @param key the key whose associated value is to be returned
+     * @return the value to which the specified key is mapped, or null if no value is mapped for the key
+     */
+    public V get(K key) {
+        // Run lazy check to clean cache
+        lazyCheck();
+
+        return internal.get(key);
+    }
+
+    /**
+     * Returns true if the specified key is mapped to a value.
+     * 
+     * @param key key to check if a mapping exists for
+     * @return true if a mapping exists for the specified key
+     */
+    public boolean containsKey(K key) {
+        // Run lazy check to clean cache
+        lazyCheck();
+
+        return internal.containsKey(key);
+    }
+
+    /**
+     * Forcibly invalidates a key, even if it is considered to be in use.
+     * 
+     * @param key key to invalidate
+     */
+    public void invalidate(K key) {
+        // Run lazy check to clean cache
+        lazyCheck();
+
+        if (!internal.containsKey(key)) {
+            // Value either not present or cleaned by lazy check. Either way, we're good
+            return;
+        }
+
+        // Remove stored object
+        internal.remove(key);
+
+        // Remove expiration entry - prevents more work later, plus prevents issues with values invalidating early
+        for (Iterator<Map.Entry<Long, K>> iterator = expiry.entries().iterator(); iterator.hasNext();) {
+            if (key.equals(iterator.next().getValue())) {
+                iterator.remove();
+                break;
+            }
+        }
+    }
+
+    /**
+     * Forcibly invalidates all keys, even if they are considered to be in use.
+     */
+    public void invalidateAll() {
+        for (V value : internal.values()) {
+            postRemoval.run(value);
+        }
+        expiry.clear();
+        internal.clear();
+    }
+
+    /**
+     * Invalidate all expired keys that are not considered in use. If a key is expired but is
+     * considered in use by the provided Function, its expiration time is reset.
+     */
+    private void lazyCheck() {
+        long now = System.currentTimeMillis();
+        long nextExpiry = now + retention;
+        for (Iterator<Map.Entry<Long, K>> iterator = expiry.entries().iterator(); iterator.hasNext();) {
+            Map.Entry<Long, K> entry = iterator.next();
+
+            if (entry.getKey() > now) {
+                break;
+            }
+
+            iterator.remove();
+
+            if (inUseCheck.run(internal.get(entry.getValue()))) {
+                expiry.put(nextExpiry, entry.getValue());
+                continue;
+            }
+
+            V value = internal.remove(entry.getValue());
+
+            if (value == null) {
+                continue;
+            }
+
+            postRemoval.run(value);
+        }
+    }
+
+}

OpenInvPlugin/src/main/java/com/lishid/openinv/util/Function.java

@@ -0,0 +1,12 @@
+package com.lishid.openinv.util;
+
+/**
+ * Abstraction for some simple cache calls.
+ * 
+ * @author Jikoo
+ */
+public abstract class Function<V> {
+
+    public abstract boolean run(V value);
+
+}

OpenInvPlugin/src/main/resources/plugin.yml

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