diff --git a/README.md b/README.md
index b417e44..f0620a6 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # OpenShulker
 
-OpenShulker is a plugin for 1.14 to 1.20.1 that makes Shulkerboxes more useful.
+OpenShulker is a plugin for 1.14 to 26.2 that makes Shulkerboxes more useful.
 
 You can open a Shulker by Shift-Rightclicking it in your hand or Inventory.
 
@@ -21,11 +21,19 @@ You can download it on spigotmc: [OpenShulker](https://www.spigotmc.org/resource
 OpenSound: "BLOCK_SHULKER_BOX_OPEN"
 # Sound for closing a Shulker
 CloseSound: "BLOCK_SHULKER_BOX_CLOSE"
+Hooks:
+  # If ChestSort is installed and this is true, opened shulker inventories are marked as unsortable.
+  ChestSort: true
+  # If WorldGuard is installed and this is true, shulkers inside protected containers can only be used where the player has container access.
+  WorldGuard: true
+# Ingame admin commands:
+# /openshulker reload - reloads this config
+# /openshulker hooks - shows if ChestSort/WorldGuard hooks are enabled and loaded
 Messages:
   Prefix: "&8[&2OpenShulker&8] &7"
-  CannotBreakContainer: "§cYou cannot break this container, since there's an opened shulker in it"
+  CannotBreakContainer: "&cYou cannot break this container, since there's an opened shulker in it"
   OpenShulkerCommand:
-    Syntax: "&cSyntax: &4/<LABEL> <Reload>"
+    Syntax: "&cSyntax: &4/<LABEL> <Reload|Hooks>"
     Reloaded: "The plugin was reloaded!"
 ```
 
@@ -38,6 +46,7 @@ Messages:
 # Commands
 
 - `openshulker reload`
+- `openshulker hooks`
 
 # Support
 
@@ -47,7 +56,4 @@ Github: [Issues Page](https://github.com/Test-Account666/OpenShulker/issues)
 
 # Todo
 
-- Add ability to input items by right clicking an item on/with a shulker box
-- Add ChestSort Hook
-- Add WorldGuard Hook
 - Add update checker
diff --git a/pom.xml b/pom.xml
index 0ce8740..e8679e2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,13 +6,14 @@
 
     <groupId>me.entity303</groupId>
     <artifactId>OpenShulker</artifactId>
-    <version>1.3.0</version>
+    <version>1.4.0</version>
     <packaging>jar</packaging>
 
     <name>OpenShulker</name>
 
     <properties>
         <java.version>1.8</java.version>
+        <paper.version>26.2.build.31-alpha</paper.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
@@ -61,13 +62,23 @@
             <id>sonatype</id>
             <url>https://oss.sonatype.org/content/groups/public/</url>
         </repository>
+        <repository>
+            <id>enginehub-repo</id>
+            <url>https://maven.enginehub.org/repo/</url>
+        </repository>
     </repositories>
 
     <dependencies>
         <dependency>
             <groupId>io.papermc.paper</groupId>
             <artifactId>paper-api</artifactId>
-            <version>1.19.4-R0.1-SNAPSHOT</version>
+            <version>${paper.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.sk89q.worldguard</groupId>
+            <artifactId>worldguard-bukkit</artifactId>
+            <version>7.0.17</version>
             <scope>provided</scope>
         </dependency>
     </dependencies>
diff --git a/src/main/java/me/entity303/openshulker/OpenShulker.java b/src/main/java/me/entity303/openshulker/OpenShulker.java
index 2d2c568..ab0b962 100644
--- a/src/main/java/me/entity303/openshulker/OpenShulker.java
+++ b/src/main/java/me/entity303/openshulker/OpenShulker.java
@@ -1,6 +1,7 @@
 package me.entity303.openshulker;
 
 import me.entity303.openshulker.commands.OpenShulkerCommand;
+import me.entity303.openshulker.hooks.ChestSortHook;
 import me.entity303.openshulker.listener.ShulkerDupeListener;
 import me.entity303.openshulker.listener.ShulkerOpenCloseListener;
 import me.entity303.openshulker.listener.ShulkerReadOnlyListener;
@@ -18,10 +19,15 @@ public final class OpenShulker extends JavaPlugin implements Listener {
     public boolean _allowContainerOpen = true;
     public boolean _allowEnderChestOpen = true;
     public boolean _allowHandOpen = true;
+    public boolean _hookChestSort = true;
+    public boolean _debugChestSort = false;
+    public boolean _hookWorldGuard = true;
     private ShulkerActions _shulkerActions;
 
     @Override
     public void onDisable() {
+        if (this._shulkerActions == null) return;
+
         for (Player all : Bukkit.getOnlinePlayers()) {
             if (!this._shulkerActions.HasOpenShulkerBox(all)) continue;
 
@@ -51,6 +57,8 @@ public void onEnable() {
 
         command.setExecutor(openShulkerCommand);
         command.setTabCompleter(openShulkerCommand);
+
+        this.LogHookStatus();
     }
 
     public void InitializeConfig() {
@@ -58,6 +66,8 @@ public void InitializeConfig() {
 
         this.reloadConfig();
 
+        this.AddConfigDefaults();
+
         String openSound = this.getConfig().getString("OpenSound");
 
         try {
@@ -80,7 +90,7 @@ public void InitializeConfig() {
         } catch (Throwable ignored) {
             if (closeSound == null) {
                 Bukkit.getLogger().severe("You did not specify CloseSound, using default");
-                this.getConfig().set("OpenSound", "BLOCK_SHULKER_BOX_CLOSE");
+                this.getConfig().set("CloseSound", "BLOCK_SHULKER_BOX_CLOSE");
                 this.saveConfig();
                 this.reloadConfig();
             } else Bukkit.getLogger()
@@ -92,6 +102,56 @@ public void InitializeConfig() {
         this._allowContainerOpen = this.getConfig().getBoolean("OpenMethods.AllowContainerOpen");
         this._allowEnderChestOpen = this.getConfig().getBoolean("OpenMethods.AllowEnderChestOpen");
         this._allowHandOpen = this.getConfig().getBoolean("OpenMethods.AllowHandOpen");
+        this._hookChestSort = this.getConfig().getBoolean("Hooks.ChestSort", true);
+        this._debugChestSort = this.getConfig().getBoolean("Hooks.ChestSortDebug", false);
+        this._hookWorldGuard = this.getConfig().getBoolean("Hooks.WorldGuard", true);
+    }
+
+    private void AddConfigDefaults() {
+        boolean changed = false;
+
+        changed |= this.AddConfigDefault("OpenMethods.AllowInventoryOpen", true);
+        changed |= this.AddConfigDefault("OpenMethods.AllowContainerOpen", true);
+        changed |= this.AddConfigDefault("OpenMethods.AllowEnderChestOpen", true);
+        changed |= this.AddConfigDefault("OpenMethods.AllowHandOpen", true);
+        changed |= this.AddConfigDefault("WaitSecondsBeforeOpen", 0);
+        changed |= this.AddConfigDefault("OpenSound", "BLOCK_SHULKER_BOX_OPEN");
+        changed |= this.AddConfigDefault("CloseSound", "BLOCK_SHULKER_BOX_CLOSE");
+        changed |= this.AddConfigDefault("Hooks.ChestSort", true);
+        changed |= this.AddConfigDefault("Hooks.ChestSortDebug", false);
+        changed |= this.AddConfigDefault("Hooks.WorldGuard", true);
+        changed |= this.AddConfigDefault("Messages.Prefix", "&8[&2OpenShulker&8] &7");
+        changed |= this.AddConfigDefault("Messages.CannotBreakContainer", "&cYou cannot break this container, since there's an opened shulker in it");
+        changed |= this.AddConfigDefault("Messages.OpenShulkerCommand.Syntax", "&cSyntax: &4/<LABEL> <Reload|Hooks>");
+        changed |= this.AddConfigDefault("Messages.OpenShulkerCommand.Reloaded", "The plugin was reloaded!");
+
+        if (!changed) return;
+
+        this.getConfig().options().copyDefaults(true);
+        this.saveConfig();
+        this.reloadConfig();
+    }
+
+    private boolean AddConfigDefault(String path, Object value) {
+        boolean missing = !this.getConfig().isSet(path);
+        this.getConfig().addDefault(path, value);
+        return missing;
+    }
+
+    private void LogHookStatus() {
+        this.getLogger().info("ChestSort hook: " + this.FormatHookStatus(this._hookChestSort, ChestSortHook.IsLoaded()));
+        this.getLogger().info("WorldGuard hook: " +
+                              this.FormatHookStatus(this._hookWorldGuard, Bukkit.getPluginManager().getPlugin("WorldGuard") != null));
+
+        if (this._hookChestSort && this._debugChestSort && ChestSortHook.IsLoaded() && !ChestSortHook.IsApiAvailable()) {
+            this.getLogger().warning("ChestSort is loaded, but OpenShulker could not find a supported ChestSortAPI#setUnsortable method.");
+        }
+    }
+
+    private String FormatHookStatus(boolean enabledInConfig, boolean pluginLoaded) {
+        if (!enabledInConfig) return "disabled in config";
+        if (!pluginLoaded) return "enabled in config, plugin not loaded";
+        return "enabled and plugin loaded";
     }
 
     public ShulkerActions GetShulkerActions() {
diff --git a/src/main/java/me/entity303/openshulker/commands/OpenShulkerCommand.java b/src/main/java/me/entity303/openshulker/commands/OpenShulkerCommand.java
index e84b080..6f06004 100644
--- a/src/main/java/me/entity303/openshulker/commands/OpenShulkerCommand.java
+++ b/src/main/java/me/entity303/openshulker/commands/OpenShulkerCommand.java
@@ -1,6 +1,8 @@
 package me.entity303.openshulker.commands;
 
 import me.entity303.openshulker.OpenShulker;
+import me.entity303.openshulker.hooks.ChestSortHook;
+import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
@@ -9,7 +11,6 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 public class OpenShulkerCommand implements TabExecutor {
@@ -42,6 +43,14 @@ public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command
             return true;
         }
 
+        if (args[0].equalsIgnoreCase("hooks")) {
+            commandSender.sendMessage(prefix + "ChestSort hook: " + this.FormatHookStatus(this._openShulker._hookChestSort, ChestSortHook.IsLoaded()));
+            commandSender.sendMessage(prefix + "WorldGuard hook: " +
+                                      this.FormatHookStatus(this._openShulker._hookWorldGuard,
+                                                            Bukkit.getPluginManager().getPlugin("WorldGuard") != null));
+            return true;
+        }
+
         commandSender.sendMessage(prefix + ChatColor.translateAlternateColorCodes('&', this._openShulker.getConfig()
                                                                                                         .getString("Messages.OpenShulkerCommand.Syntax")
                                                                                                         .replace("<LABEL>", label)));
@@ -51,8 +60,19 @@ public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command
     @Override
     public @Nullable List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                                                 @NotNull String[] args) {
-        if (args.length == 1) return Collections.singletonList("reload");
+        if (args.length == 1) {
+            List<String> completions = new ArrayList<>();
+            completions.add("reload");
+            completions.add("hooks");
+            return completions;
+        }
 
         return new ArrayList<>();
     }
+
+    private String FormatHookStatus(boolean enabledInConfig, boolean pluginLoaded) {
+        if (!enabledInConfig) return ChatColor.RED + "disabled in config";
+        if (!pluginLoaded) return ChatColor.YELLOW + "enabled in config, plugin not loaded";
+        return ChatColor.GREEN + "enabled";
+    }
 }
diff --git a/src/main/java/me/entity303/openshulker/hooks/ChestSortHook.java b/src/main/java/me/entity303/openshulker/hooks/ChestSortHook.java
new file mode 100644
index 0000000..d7d3d4d
--- /dev/null
+++ b/src/main/java/me/entity303/openshulker/hooks/ChestSortHook.java
@@ -0,0 +1,92 @@
+package me.entity303.openshulker.hooks;
+
+import org.bukkit.Bukkit;
+import org.bukkit.inventory.Inventory;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+public final class ChestSortHook {
+    private static final String[] API_CLASSES = {
+            "de.jeff_media.chestsort.api.ChestSortAPI",
+            "de.jeff_media.chestsort.ChestSortAPI"
+    };
+    private static boolean _warnedMissingApi = false;
+
+    private ChestSortHook() {
+    }
+
+    public static void SetUnsortable(Inventory inventory, boolean debug) {
+        if (!IsLoaded()) return;
+        if (inventory == null) return;
+
+        for (String apiClass : API_CLASSES) {
+            if (TrySetUnsortable(apiClass, inventory)) return;
+        }
+
+        if (debug && !_warnedMissingApi) {
+            Bukkit.getLogger().warning("[OpenShulker] ChestSort is loaded, but no supported ChestSortAPI#setUnsortable method was found.");
+            _warnedMissingApi = true;
+        }
+    }
+
+    public static boolean IsLoaded() {
+        return Bukkit.getPluginManager().getPlugin("ChestSort") != null;
+    }
+
+    public static boolean IsApiAvailable() {
+        if (!IsLoaded()) return false;
+
+        for (String apiClass : API_CLASSES) {
+            try {
+                Class<?> chestSortApi = Class.forName(apiClass);
+                if (FindUnsortableMethod(chestSortApi) != null) return true;
+            } catch (Throwable ignored) {
+            }
+        }
+
+        return false;
+    }
+
+    private static boolean TrySetUnsortable(String apiClass, Inventory inventory) {
+        try {
+            Class<?> chestSortApi = Class.forName(apiClass);
+
+            try {
+                Method setUnsortable = chestSortApi.getMethod("setUnsortable", Inventory.class);
+                setUnsortable.invoke(null, inventory);
+                return true;
+            } catch (NoSuchMethodException ignored) {
+                return TryMatchingUnsortableMethod(chestSortApi, inventory);
+            }
+        } catch (Throwable ignored) {
+            return false;
+        }
+    }
+
+    private static boolean TryMatchingUnsortableMethod(Class<?> chestSortApi, Inventory inventory) {
+        Method method = FindUnsortableMethod(chestSortApi);
+
+        if (method == null) return false;
+
+        try {
+            method.invoke(null, inventory);
+            return true;
+        } catch (Throwable ignored) {
+            return false;
+        }
+    }
+
+    private static Method FindUnsortableMethod(Class<?> chestSortApi) {
+        for (Method method : chestSortApi.getMethods()) {
+            if (!Modifier.isStatic(method.getModifiers())) continue;
+            if (!method.getName().toLowerCase().contains("unsort")) continue;
+            if (method.getParameterTypes().length != 1) continue;
+            if (!method.getParameterTypes()[0].isAssignableFrom(Inventory.class)) continue;
+
+            return method;
+        }
+
+        return null;
+    }
+}
diff --git a/src/main/java/me/entity303/openshulker/hooks/WorldGuardHook.java b/src/main/java/me/entity303/openshulker/hooks/WorldGuardHook.java
new file mode 100644
index 0000000..091f1f7
--- /dev/null
+++ b/src/main/java/me/entity303/openshulker/hooks/WorldGuardHook.java
@@ -0,0 +1,37 @@
+package me.entity303.openshulker.hooks;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.regions.RegionContainer;
+import com.sk89q.worldguard.protection.regions.RegionQuery;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+public final class WorldGuardHook {
+    private WorldGuardHook() {
+    }
+
+    public static boolean CanAccessContainer(Player player, Location location) {
+        if (Bukkit.getPluginManager().getPlugin("WorldGuard") == null) return true;
+        if (location == null || location.getWorld() == null) return true;
+
+        try {
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+
+            if (WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, BukkitAdapter.adapt(location.getWorld()))) {
+                return true;
+            }
+
+            RegionContainer container = WorldGuard.getInstance().getPlatform().getRegionContainer();
+            RegionQuery query = container.createQuery();
+
+            return query.testState(BukkitAdapter.adapt(location), localPlayer, Flags.CHEST_ACCESS, Flags.INTERACT);
+        } catch (Throwable ignored) {
+            return true;
+        }
+    }
+}
diff --git a/src/main/java/me/entity303/openshulker/listener/ShulkerDupeListener.java b/src/main/java/me/entity303/openshulker/listener/ShulkerDupeListener.java
index 3ff1ce4..644121a 100644
--- a/src/main/java/me/entity303/openshulker/listener/ShulkerDupeListener.java
+++ b/src/main/java/me/entity303/openshulker/listener/ShulkerDupeListener.java
@@ -65,6 +65,8 @@ public void OnInteractEntity(PlayerInteractEntityEvent event) {
 
     @EventHandler(ignoreCancelled = true)
     public void OnCraft(CraftItemEvent event) {
+        if (!(event.getWhoClicked() instanceof Player)) return;
+
         if (!this.HandleEvent(event, (Player) event.getWhoClicked())) return;
 
         event.setResult(Event.Result.DENY);
@@ -138,6 +140,8 @@ public void OnDupedShulkerPlace(PlayerInteractEvent event) {
 
     @EventHandler
     public void OnInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player)) return;
+
         int slot = event.getSlot();
 
         if (event.getClickedInventory() == null) return;
@@ -148,11 +152,13 @@ public void OnInventoryClick(InventoryClickEvent event) {
 
         if (clickedItemStack.getType() == Material.AIR) return;
 
-        if (!this._openShulker.GetShulkerActions().HasOpenShulkerBox((Player) event.getWhoClicked())) return;
+        Player player = (Player) event.getWhoClicked();
+
+        if (!this._openShulker.GetShulkerActions().HasOpenShulkerBox(player)) return;
 
         //Make operator can modify shulkerbox's NBT to reset it, which can solve some strange bugs caused by PersistentDataContainer
         //Like player has closed shulkerbox but the dataContainer still contains player's UUID so that player can't interact with the shulkerbox
-        if (!this._openShulker.GetShulkerActions().IsOpenShulker(clickedItemStack) || event.getWhoClicked().isOp())
+        if (!this._openShulker.GetShulkerActions().IsOpenShulker(clickedItemStack) || player.isOp())
             return;
 
         if (event.isRightClick() && event.isShiftClick()) return;
@@ -162,6 +168,8 @@ public void OnInventoryClick(InventoryClickEvent event) {
 
     @EventHandler
     public void OnInventoryClick2(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player)) return;
+
         int slot = event.getSlot();
 
         if (event.getClickedInventory() == null) return;
@@ -172,7 +180,9 @@ public void OnInventoryClick2(InventoryClickEvent event) {
 
         if (clickedItemStack.getType() == Material.AIR) return;
 
-        if (this._openShulker.GetShulkerActions().HasOpenShulkerBox((Player) event.getWhoClicked())) return;
+        Player player = (Player) event.getWhoClicked();
+
+        if (this._openShulker.GetShulkerActions().HasOpenShulkerBox(player)) return;
 
         if (!this._openShulker.GetShulkerActions().IsOpenShulker(clickedItemStack)) return;
 
diff --git a/src/main/java/me/entity303/openshulker/listener/ShulkerOpenCloseListener.java b/src/main/java/me/entity303/openshulker/listener/ShulkerOpenCloseListener.java
index 6a368af..63ae768 100644
--- a/src/main/java/me/entity303/openshulker/listener/ShulkerOpenCloseListener.java
+++ b/src/main/java/me/entity303/openshulker/listener/ShulkerOpenCloseListener.java
@@ -1,10 +1,11 @@
 package me.entity303.openshulker.listener;
 
 import me.entity303.openshulker.OpenShulker;
-import org.bukkit.Bukkit;
+import me.entity303.openshulker.hooks.ChestSortHook;
+import me.entity303.openshulker.hooks.WorldGuardHook;
+import me.entity303.openshulker.util.SchedulerUtil;
 import org.bukkit.Location;
 import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
 import org.bukkit.block.Container;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
@@ -20,18 +21,12 @@
 import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.persistence.PersistentDataContainer;
-import org.bukkit.persistence.PersistentDataType;
 
 public class ShulkerOpenCloseListener implements Listener {
     private final OpenShulker _openShulker;
-    private final NamespacedKey _clickedShulkerKey;
 
     public ShulkerOpenCloseListener(OpenShulker openShulker) {
         this._openShulker = openShulker;
-
-        this._clickedShulkerKey = new NamespacedKey(this._openShulker, "clickedshulker");
     }
 
     @EventHandler(priority = EventPriority.LOWEST)
@@ -47,12 +42,16 @@ public void OnShulkerOpen(PlayerInteractEvent event) {
         //Don't open shulkerbox when interact with hopper
         if (event.getClickedBlock() != null && event.getClickedBlock().getType() == Material.HOPPER) return;
 
-        event.setCancelled(this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox(event.getPlayer()));
+        if (this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox(event.getPlayer())) event.setCancelled(true);
     }
 
     @EventHandler(ignoreCancelled = true)
     public void OnShulkerOpenAlternative(InventoryClickEvent event) {
-        if (!event.getWhoClicked().hasPermission("openshulker.use")) return;
+        if (!(event.getWhoClicked() instanceof Player)) return;
+
+        Player player = (Player) event.getWhoClicked();
+
+        if (!player.hasPermission("openshulker.use")) return;
 
         if (event.getClickedInventory() == null) return;
 
@@ -64,27 +63,43 @@ public void OnShulkerOpenAlternative(InventoryClickEvent event) {
 
         if (clickedItemStack.getType() == Material.AIR) return;
 
+        if (this.HandleShulkerItemInput(event, player, clickedItemStack, clickedSlot)) return;
+
         if (!clickedItemStack.getType().name().contains(Material.SHULKER_BOX.name())) return;
 
         if (!event.isRightClick()) return;
 
         if (!event.isShiftClick()) return;
 
+        if (event.getCursor() != null && event.getCursor().getType() != Material.AIR) return;
+
         if (event.getClickedInventory() == event.getWhoClicked().getInventory()) {
             if (!this._openShulker._allowInventoryOpen) return;
 
             if (event.getView().getTopInventory().getType() == InventoryType.SHULKER_BOX) {
-                if (this._openShulker.GetShulkerActions().HasOpenShulkerBox((Player) event.getWhoClicked())) {
-                    ItemStack shulkerBox = this._openShulker.GetShulkerActions().SearchShulkerBox((Player) event.getWhoClicked());
+                if (this._openShulker.GetShulkerActions().IsOpenShulker(clickedItemStack, player)) {
+                    boolean enderChest = this._openShulker.GetShulkerActions().HasOpenShulkerInEnderChest(player);
+
+                    Container container = this._openShulker.GetShulkerActions().GetShulkerHoldingContainer(player);
+
+                    this._openShulker.GetShulkerActions().SaveShulkerBox(clickedItemStack, event.getView().getTopInventory(), player);
+
+                    event.setCancelled(true);
+                    this.ReopenInventory(enderChest, container, player);
+                    return;
+                }
+
+                if (this._openShulker.GetShulkerActions().HasOpenShulkerBox(player)) {
+                    ItemStack shulkerBox = this._openShulker.GetShulkerActions().SearchShulkerBox(player);
 
-                    this._openShulker.GetShulkerActions().SaveShulkerBox(shulkerBox, event.getView().getTopInventory(), (Player) event.getWhoClicked());
+                    this._openShulker.GetShulkerActions().SaveShulkerBox(shulkerBox, event.getView().getTopInventory(), player);
                 }
 
                 //Close inventory to prevent overriding open shulker contents
                 event.getWhoClicked().closeInventory();
             }
 
-            boolean open = this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox((Player) event.getWhoClicked(), clickedItemStack);
+            boolean open = this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox(player, clickedItemStack);
 
             if (!open) return;
             event.setCancelled(true);
@@ -93,9 +108,9 @@ public void OnShulkerOpenAlternative(InventoryClickEvent event) {
 
         if (event.getClickedInventory().getType() == InventoryType.ENDER_CHEST) {
             if (!this._openShulker._allowEnderChestOpen) return;
-            if (!this.IsOwnerOfEnderChest((Player) event.getWhoClicked(), clickedItemStack, clickedSlot)) return;
+            if (!this.IsOwnerOfEnderChest(player, event.getClickedInventory(), clickedItemStack, clickedSlot)) return;
 
-            boolean open = this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox((Player) event.getWhoClicked(), clickedItemStack, true);
+            boolean open = this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox(player, clickedItemStack, true);
 
             if (!open) return;
             event.setCancelled(true);
@@ -108,49 +123,80 @@ public void OnShulkerOpenAlternative(InventoryClickEvent event) {
 
         if (location == null) return;
 
-        boolean open = this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox((Player) event.getWhoClicked(), clickedItemStack, location);
+        if (!this.CanUseInventoryLocation(player, location)) {
+            event.setCancelled(true);
+            return;
+        }
+
+        boolean open = this._openShulker.GetShulkerActions().AttemptToOpenShulkerBox(player, clickedItemStack, location);
 
         if (!open) return;
         event.setCancelled(true);
     }
 
-    //Awful code, I know, but I don't see a better way
-    private boolean IsOwnerOfEnderChest(Player player, ItemStack clickedItemStack, int clickedSlot) {
-        ItemMeta clickedItemMeta = clickedItemStack.getItemMeta();
+    private boolean HandleShulkerItemInput(InventoryClickEvent event, Player player, ItemStack clickedItemStack, int clickedSlot) {
+        if (!event.isRightClick()) return false;
 
-        PersistentDataContainer clickedItemContainer = clickedItemMeta.getPersistentDataContainer();
+        ItemStack cursorItemStack = event.getCursor();
 
-        clickedItemContainer.set(this._clickedShulkerKey, PersistentDataType.STRING, player.getUniqueId().toString());
+        if (cursorItemStack == null) return false;
 
-        clickedItemStack.setItemMeta(clickedItemMeta);
+        if (cursorItemStack.getType() == Material.AIR) return false;
 
+        boolean inputCursorIntoClicked = this._openShulker.GetShulkerActions()
+                                                          .CanInputIntoShulkerBox(player, clickedItemStack, cursorItemStack);
+        boolean inputClickedIntoCursor = this._openShulker.GetShulkerActions()
+                                                          .CanInputIntoShulkerBox(player, cursorItemStack, clickedItemStack);
 
-        ItemStack potentiallyClickedItem = player.getEnderChest().getItem(clickedSlot);
+        if (!inputCursorIntoClicked && !inputClickedIntoCursor) return false;
+
+        Location location = event.getClickedInventory().getLocation();
+        if (!this.CanUseInventoryLocation(player, location)) {
+            event.setCancelled(true);
+            return true;
+        }
 
-        if (potentiallyClickedItem == null) {
-            clickedItemContainer.remove(this._clickedShulkerKey);
+        if (inputCursorIntoClicked) {
+            ItemStack leftover = this._openShulker.GetShulkerActions().InputItemIntoShulkerBox(clickedItemStack, cursorItemStack);
 
-            clickedItemStack.setItemMeta(clickedItemMeta);
-            return false;
+            event.getClickedInventory().setItem(clickedSlot, clickedItemStack);
+            event.setCursor(leftover);
+            event.setCancelled(true);
+            return true;
         }
 
-        ItemMeta potentiallyClickedItemMeta = potentiallyClickedItem.getItemMeta();
+        if (inputClickedIntoCursor) {
+            ItemStack leftover = this._openShulker.GetShulkerActions().InputItemIntoShulkerBox(cursorItemStack, clickedItemStack);
 
-        PersistentDataContainer potentiallyClickedItemContainer = potentiallyClickedItemMeta.getPersistentDataContainer();
+            event.setCursor(cursorItemStack);
+            event.getClickedInventory().setItem(clickedSlot, leftover);
+            event.setCancelled(true);
+            return true;
+        }
+
+        return false;
+    }
 
-        boolean isOwner = false;
+    private boolean CanUseInventoryLocation(Player player, Location location) {
+        if (!this._openShulker._hookWorldGuard) return true;
 
-        if (potentiallyClickedItemContainer.has(this._clickedShulkerKey, PersistentDataType.STRING)) {
-            String uuid = potentiallyClickedItemContainer.get(this._clickedShulkerKey, PersistentDataType.STRING);
+        if (location == null) return true;
 
-            isOwner = uuid.equalsIgnoreCase(player.getUniqueId().toString());
+        try {
+            return WorldGuardHook.CanAccessContainer(player, location);
+        } catch (Throwable ignored) {
+            return true;
         }
+    }
+
+    private boolean IsOwnerOfEnderChest(Player player, Inventory clickedInventory, ItemStack clickedItemStack, int clickedSlot) {
+        if (!player.getEnderChest().equals(clickedInventory)) return false;
 
-        clickedItemContainer.remove(this._clickedShulkerKey);
+        ItemStack potentiallyClickedItem = player.getEnderChest().getItem(clickedSlot);
 
-        clickedItemStack.setItemMeta(clickedItemMeta);
+        if (potentiallyClickedItem == null) return false;
 
-        return isOwner;
+        return potentiallyClickedItem.isSimilar(clickedItemStack);
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -161,7 +207,7 @@ public void OnShulkerItemDrop(PlayerDropItemEvent event) {
 
         if (!this._openShulker.GetShulkerActions().IsOpenShulker(shulkerBox, event.getPlayer())) return;
 
-        boolean enderChest = this._openShulker.GetShulkerActions().HasOpenShulkerInEnderChest((Player) event.getPlayer());
+        boolean enderChest = this._openShulker.GetShulkerActions().HasOpenShulkerInEnderChest(event.getPlayer());
 
         Container container = this._openShulker.GetShulkerActions().GetShulkerHoldingContainer(event.getPlayer());
 
@@ -173,37 +219,44 @@ public void OnShulkerItemDrop(PlayerDropItemEvent event) {
     private void ReopenInventory(boolean enderChest, Container container, HumanEntity player) {
         player.closeInventory();
 
-        Bukkit.getScheduler().runTaskLater(this._openShulker, () -> {
+        SchedulerUtil.RunEntityLater(this._openShulker, player, () -> {
             if (container != null) {
                 if (container.getWorld() != player.getWorld()) return;
 
                 if (container.getLocation().distance(player.getLocation()) > 4) return;
 
                 player.openInventory(container.getInventory());
+                if (this._openShulker._hookChestSort) {
+                    ChestSortHook.SetUnsortable(player.getOpenInventory().getTopInventory(), this._openShulker._debugChestSort);
+                }
                 return;
             }
 
-            if (!enderChest) return;
-
-            player.openInventory(player.getEnderChest());
+            if (enderChest) {
+                player.openInventory(player.getEnderChest());
+            }
         }, 1L);
     }
 
     @EventHandler
     public void OnShulkerInventoryClose(InventoryCloseEvent event) {
+        if (!(event.getPlayer() instanceof Player)) return;
+
         if (event.getInventory().getType() != InventoryType.SHULKER_BOX) return;
 
-        if (!this._openShulker.GetShulkerActions().HasOpenShulkerBox((Player) event.getPlayer())) return;
+        Player player = (Player) event.getPlayer();
+
+        if (!this._openShulker.GetShulkerActions().HasOpenShulkerBox(player)) return;
 
-        ItemStack itemStack = this._openShulker.GetShulkerActions().SearchShulkerBox((Player) event.getPlayer());
+        ItemStack itemStack = this._openShulker.GetShulkerActions().SearchShulkerBox(player);
 
         if (itemStack == null) return;
 
-        boolean enderChest = this._openShulker.GetShulkerActions().HasOpenShulkerInEnderChest((Player) event.getPlayer());
+        boolean enderChest = this._openShulker.GetShulkerActions().HasOpenShulkerInEnderChest(player);
 
-        Container container = this._openShulker.GetShulkerActions().GetShulkerHoldingContainer((Player) event.getPlayer());
+        Container container = this._openShulker.GetShulkerActions().GetShulkerHoldingContainer(player);
 
-        this._openShulker.GetShulkerActions().SaveShulkerBox(itemStack, event.getInventory(), (Player) event.getPlayer());
+        this._openShulker.GetShulkerActions().SaveShulkerBox(itemStack, event.getInventory(), player);
 
         this.ReopenInventory(enderChest, container, event.getPlayer());
     }
diff --git a/src/main/java/me/entity303/openshulker/listener/ShulkerReadOnlyListener.java b/src/main/java/me/entity303/openshulker/listener/ShulkerReadOnlyListener.java
index e32537b..73e519c 100644
--- a/src/main/java/me/entity303/openshulker/listener/ShulkerReadOnlyListener.java
+++ b/src/main/java/me/entity303/openshulker/listener/ShulkerReadOnlyListener.java
@@ -16,11 +16,15 @@ public ShulkerReadOnlyListener(OpenShulker openShulker) {
 
     @EventHandler
     public void OnShulkerInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player)) return;
+
         if (event.getView().getTopInventory().getType() != InventoryType.SHULKER_BOX) return;
 
-        if (!this._openShulker.GetShulkerActions().HasOpenShulkerBox((Player) event.getWhoClicked())) return;
+        Player player = (Player) event.getWhoClicked();
+
+        if (!this._openShulker.GetShulkerActions().HasOpenShulkerBox(player)) return;
 
-        if (event.getWhoClicked().hasPermission("openshulker.write")) return;
+        if (player.hasPermission("openshulker.write")) return;
 
         event.setCancelled(true);
     }
diff --git a/src/main/java/me/entity303/openshulker/util/SchedulerUtil.java b/src/main/java/me/entity303/openshulker/util/SchedulerUtil.java
new file mode 100644
index 0000000..e437c81
--- /dev/null
+++ b/src/main/java/me/entity303/openshulker/util/SchedulerUtil.java
@@ -0,0 +1,70 @@
+package me.entity303.openshulker.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Method;
+import java.util.function.Consumer;
+
+public final class SchedulerUtil {
+    private SchedulerUtil() {
+    }
+
+    public static void RunEntityLater(Plugin plugin, Entity entity, Runnable task, long delayTicks) {
+        if (delayTicks <= 0) {
+            if (TryRunEntity(plugin, entity, task)) return;
+
+            Bukkit.getScheduler().runTask(plugin, task);
+            return;
+        }
+
+        if (TryRunEntityLater(plugin, entity, task, delayTicks)) return;
+
+        Bukkit.getScheduler().runTaskLater(plugin, task, delayTicks);
+    }
+
+    private static boolean TryRunEntity(Plugin plugin, Entity entity, Runnable task) {
+        try {
+            Object scheduler = GetEntityScheduler(entity);
+            Method run = scheduler.getClass().getMethod("run", Plugin.class, Consumer.class, Runnable.class);
+
+            Consumer<Object> scheduledTask = ignored -> task.run();
+            Runnable retired = () -> {
+            };
+
+            run.invoke(scheduler, plugin, scheduledTask, retired);
+            return true;
+        } catch (NoSuchMethodException ignored) {
+            return false;
+        } catch (Throwable throwable) {
+            plugin.getLogger().warning("Failed to schedule entity task, falling back to Bukkit scheduler: " + throwable.getMessage());
+            return false;
+        }
+    }
+
+    private static boolean TryRunEntityLater(Plugin plugin, Entity entity, Runnable task, long delayTicks) {
+        try {
+            Object scheduler = GetEntityScheduler(entity);
+            Method runDelayed = scheduler.getClass()
+                                         .getMethod("runDelayed", Plugin.class, Consumer.class, Runnable.class, long.class);
+
+            Consumer<Object> scheduledTask = ignored -> task.run();
+            Runnable retired = () -> {
+            };
+
+            runDelayed.invoke(scheduler, plugin, scheduledTask, retired, delayTicks);
+            return true;
+        } catch (NoSuchMethodException ignored) {
+            return false;
+        } catch (Throwable throwable) {
+            plugin.getLogger().warning("Failed to schedule entity task, falling back to Bukkit scheduler: " + throwable.getMessage());
+            return false;
+        }
+    }
+
+    private static Object GetEntityScheduler(Entity entity) throws Exception {
+        Method getScheduler = entity.getClass().getMethod("getScheduler");
+        return getScheduler.invoke(entity);
+    }
+}
diff --git a/src/main/java/me/entity303/openshulker/util/ShulkerActions.java b/src/main/java/me/entity303/openshulker/util/ShulkerActions.java
index 5570e55..a4fbefd 100644
--- a/src/main/java/me/entity303/openshulker/util/ShulkerActions.java
+++ b/src/main/java/me/entity303/openshulker/util/ShulkerActions.java
@@ -1,6 +1,7 @@
 package me.entity303.openshulker.util;
 
 import me.entity303.openshulker.OpenShulker;
+import me.entity303.openshulker.hooks.ChestSortHook;
 import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.Container;
@@ -14,6 +15,9 @@
 import org.bukkit.persistence.PersistentDataContainer;
 import org.bukkit.persistence.PersistentDataType;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class ShulkerActions {
     private final NamespacedKey _openShulkerKey;
     private final NamespacedKey _openShulkerLocationKey;
@@ -49,7 +53,7 @@ public void SaveShulkerBox(ItemStack shulkerBoxStack, Inventory inventory, Playe
         container.remove(this._openShulkerLocationKey);
 
         try {
-            player.playSound(player, Sound.valueOf(this._openShulker.getConfig().getString("CloseSound")), 1F, 1F);
+            player.playSound(player.getLocation(), Sound.valueOf(this._openShulker.getConfig().getString("CloseSound")), 1F, 1F);
         } catch (Throwable ignored) {
             //Ignore the exception, it's probably just a message about not being able to find the correct sound
             //We have an info message in OpenShulker#onEnable for this
@@ -63,15 +67,19 @@ public boolean HasOpenShulkerBox(Player player) {
 
         if (!container.has(this._openShulkerKey, PersistentDataType.STRING)) {
             if (itemStack != null) {
-                Bukkit.getLogger().severe("Player " + player.getName() + " (" + player.getUniqueId() + ") may have duped!");
-                Bukkit.getLogger().severe("Found opened Shulker while not having a shulker open!");
+                this._openShulker.getLogger()
+                                 .warning("Recovered stale open shulker item state for " + player.getName() + " (" +
+                                          player.getUniqueId() + ").");
+                this.ClearOpenShulkerState(itemStack, player);
             }
             return false;
         }
 
         if (itemStack == null) {
-            Bukkit.getLogger().severe("Player " + player.getName() + " (" + player.getUniqueId() + ") may have duped!");
-            Bukkit.getLogger().severe("Currently viewing a shulker while not having an opened shulker!");
+            this._openShulker.getLogger()
+                             .warning("Recovered stale open shulker player state for " + player.getName() + " (" +
+                                      player.getUniqueId() + ").");
+            this.ClearPlayerOpenShulkerState(player);
             return false;
         }
 
@@ -86,6 +94,8 @@ public ItemStack SearchShulkerBox(Player player) {
         if (dataContainer.has(this._openShulkerLocationKey, PersistentDataType.STRING)) {
             Container container = this.GetShulkerHoldingContainer(player);
 
+            if (container == null) return null;
+
             return this.SearchShulkerBox(container.getInventory(), player);
         }
 
@@ -120,13 +130,25 @@ public Container GetShulkerHoldingContainer(Player player) {
         if (!dataContainer.has(this._openShulkerLocationKey, PersistentDataType.STRING)) return null;
 
         String locationString = dataContainer.get(this._openShulkerLocationKey, PersistentDataType.STRING);
+        if (locationString == null) return null;
+
         String[] locationStringArray = locationString.split(";");
+        if (locationStringArray.length != 4) return null;
 
-        double xCoordinate = Double.parseDouble(locationStringArray[0]);
-        double yCoordinate = Double.parseDouble(locationStringArray[1]);
-        double zCoordinate = Double.parseDouble(locationStringArray[2]);
+        double xCoordinate;
+        double yCoordinate;
+        double zCoordinate;
+
+        try {
+            xCoordinate = Double.parseDouble(locationStringArray[0]);
+            yCoordinate = Double.parseDouble(locationStringArray[1]);
+            zCoordinate = Double.parseDouble(locationStringArray[2]);
+        } catch (NumberFormatException ignored) {
+            return null;
+        }
 
         World world = Bukkit.getWorld(locationStringArray[3]);
+        if (world == null) return null;
 
         Location location = new Location(world, xCoordinate, yCoordinate, zCoordinate);
 
@@ -154,6 +176,8 @@ public ItemStack SearchShulkerBox(Inventory inventory) {
     }
 
     public boolean IsOpenShulker(ItemStack itemStack, Player player) {
+        if (itemStack == null) return false;
+
         ItemMeta meta = itemStack.getItemMeta();
 
         if (!(itemStack.getItemMeta() instanceof BlockStateMeta)) return false;
@@ -177,6 +201,53 @@ public boolean IsOpenShulker(ItemStack itemStack) {
         return this.IsOpenShulker(itemStack, null);
     }
 
+    public boolean IsShulkerBox(ItemStack itemStack) {
+        if (itemStack == null) return false;
+
+        if (itemStack.getType() == Material.AIR) return false;
+
+        return itemStack.getType().name().contains(Material.SHULKER_BOX.name());
+    }
+
+    public boolean CanInputIntoShulkerBox(Player player, ItemStack shulkerBoxStack, ItemStack itemStack) {
+        if (!player.hasPermission("openshulker.write")) return false;
+
+        if (!this.IsShulkerBox(shulkerBoxStack)) return false;
+
+        if (itemStack == null) return false;
+
+        if (itemStack.getType() == Material.AIR) return false;
+
+        if (this.IsShulkerBox(itemStack)) return false;
+
+        if (shulkerBoxStack.getAmount() != 1) return false;
+
+        if (this.IsOpenShulker(shulkerBoxStack)) return false;
+
+        if (!(shulkerBoxStack.getItemMeta() instanceof BlockStateMeta)) return false;
+
+        BlockStateMeta blockStateMeta = (BlockStateMeta) shulkerBoxStack.getItemMeta();
+
+        return blockStateMeta.getBlockState() instanceof ShulkerBox;
+    }
+
+    public ItemStack InputItemIntoShulkerBox(ItemStack shulkerBoxStack, ItemStack itemStack) {
+        BlockStateMeta blockStateMeta = (BlockStateMeta) shulkerBoxStack.getItemMeta();
+        ShulkerBox shulkerBox = (ShulkerBox) blockStateMeta.getBlockState();
+        Inventory inventory = shulkerBox.getInventory();
+
+        HashMap<Integer, ItemStack> leftovers = inventory.addItem(itemStack.clone());
+
+        blockStateMeta.setBlockState(shulkerBox);
+        shulkerBoxStack.setItemMeta(blockStateMeta);
+
+        if (leftovers.isEmpty()) return null;
+
+        for (Map.Entry<Integer, ItemStack> entry : leftovers.entrySet()) return entry.getValue();
+
+        return null;
+    }
+
     public boolean AttemptToOpenShulkerBox(Player player) {
         ItemStack itemStack = player.getInventory().getItemInMainHand();
 
@@ -186,6 +257,8 @@ public boolean AttemptToOpenShulkerBox(Player player) {
     public boolean AttemptToOpenShulkerBox(Player player, ItemStack itemStack) {
         if (!player.hasPermission("openshulker.use")) return false;
 
+        if (itemStack == null) return false;
+
         if (itemStack.getAmount() <= 0) return false;
 
         if (itemStack.getAmount() > 1) return false;
@@ -214,17 +287,39 @@ public boolean AttemptToOpenShulkerBox(Player player, ItemStack itemStack) {
 
         container.set(this._openShulkerKey, PersistentDataType.STRING, player.getUniqueId().toString());
 
-        Inventory inventory = Bukkit.createInventory(null, InventoryType.SHULKER_BOX);
+        String inventoryTitle = meta.hasDisplayName() ? meta.getDisplayName() : null;
+        Inventory inventory = inventoryTitle == null ? Bukkit.createInventory(null, InventoryType.SHULKER_BOX) : Bukkit.createInventory(null, InventoryType.SHULKER_BOX, inventoryTitle);
+
+        if (this._openShulker._hookChestSort) ChestSortHook.SetUnsortable(inventory, this._openShulker._debugChestSort);
+
+        SchedulerUtil.RunEntityLater(this._openShulker, player, () -> {
+            if (!player.isOnline()) {
+                this.ClearOpenShulkerState(itemStack, player);
+                return;
+            }
+
+            ItemStack currentOpenShulker = this.SearchShulkerBox(player);
+
+            if (currentOpenShulker == null || !this.IsOpenShulker(currentOpenShulker, player)) {
+                this.ClearOpenShulkerState(itemStack, player);
+                return;
+            }
+
+            if (currentOpenShulker != itemStack && !currentOpenShulker.equals(itemStack)) {
+                this.ClearOpenShulkerState(itemStack, player);
+                return;
+            }
 
-        PersistentDataContainer playerContainer = player.getPersistentDataContainer();
-        Bukkit.getScheduler().runTaskLater(this._openShulker, () -> {
             inventory.setContents(shulker.getInventory().getContents());
 
             player.openInventory(inventory);
+            if (this._openShulker._hookChestSort) {
+                ChestSortHook.SetUnsortable(player.getOpenInventory().getTopInventory(), this._openShulker._debugChestSort);
+            }
         }, this._openShulker.getConfig().getLong("WaitSecondsBeforeOpen", 0) * 20);
 
         try {
-            player.playSound(player, Sound.valueOf(this._openShulker.getConfig().getString("OpenSound")), 1F, 1F);
+            player.playSound(player.getLocation(), Sound.valueOf(this._openShulker.getConfig().getString("OpenSound")), 1F, 1F);
         } catch (Throwable ignored) {
             //Ignore the exception, it's probably just a message about not being able to find the correct sound
             //We have an info message in OpenShulker#onEnable for this
@@ -232,7 +327,26 @@ public boolean AttemptToOpenShulkerBox(Player player, ItemStack itemStack) {
         return true;
     }
 
+    private void ClearOpenShulkerState(ItemStack itemStack, Player player) {
+        if (itemStack != null && itemStack.getItemMeta() instanceof BlockStateMeta) {
+            ItemMeta meta = itemStack.getItemMeta();
+            meta.getPersistentDataContainer().remove(this._openShulkerKey);
+            itemStack.setItemMeta(meta);
+        }
+
+        this.ClearPlayerOpenShulkerState(player);
+    }
+
+    private void ClearPlayerOpenShulkerState(Player player) {
+        PersistentDataContainer container = player.getPersistentDataContainer();
+
+        container.remove(this._openShulkerKey);
+        container.remove(this._openShulkerLocationKey);
+    }
+
     public boolean AttemptToOpenShulkerBox(Player player, ItemStack itemStack, Location chest) {
+        if (chest == null || chest.getWorld() == null) return false;
+
         Block block = chest.getBlock();
 
         if (!(block.getState() instanceof Container)) return false;
diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml
index 2819d4e..c61eba8 100644
--- a/src/main/resources/config.yml
+++ b/src/main/resources/config.yml
@@ -6,9 +6,35 @@ OpenMethods:
 WaitSecondsBeforeOpen: 0
 OpenSound: "BLOCK_SHULKER_BOX_OPEN"
 CloseSound: "BLOCK_SHULKER_BOX_CLOSE"
+Hooks:
+  # If ChestSort is installed and this is true, opened shulker inventories are marked as unsortable.
+  ChestSort: true
+  # If true, OpenShulker logs a warning when ChestSort is installed but its API could not be used.
+  ChestSortDebug: false
+  # If WorldGuard is installed and this is true, shulkers inside protected containers can only be used where the player has container access.
+  # OpenShulker checks the WorldGuard flags chest-access and interact.
+  #
+  # WorldGuard ingame setup:
+  # 1. Select/create your region as usual.
+  # 2. Allow players to use shulkers in containers in that region:
+  #    /rg flag <region> chest-access allow
+  #    /rg flag <region> interact allow
+  # 3. Block players from changing shulkers in protected containers:
+  #    /rg flag <region> chest-access deny
+  #    /rg flag <region> interact deny
+  # 4. For the global region, use:
+  #    /rg flag __global__ chest-access deny
+  #    /rg flag __global__ interact deny
+  # 5. After changing this config value, reload OpenShulker:
+  #    /openshulker reload
+  #    /openshulker hooks
+  WorldGuard: true
+# Ingame admin commands:
+# /openshulker reload - reloads this config
+# /openshulker hooks - shows if ChestSort/WorldGuard hooks are enabled and loaded
 Messages:
   Prefix: "&8[&2OpenShulker&8] &7"
-  CannotBreakContainer: "§cYou cannot break this container, since there's an opened shulker in it"
+  CannotBreakContainer: "&cYou cannot break this container, since there's an opened shulker in it"
   OpenShulkerCommand:
-    Syntax: "&cSyntax: &4/<LABEL> <Reload>"
-    Reloaded: "The plugin was reloaded!"
\ No newline at end of file
+    Syntax: "&cSyntax: &4/<LABEL> <Reload|Hooks>"
+    Reloaded: "The plugin was reloaded!"
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml
index 7892735..a7b7c65 100644
--- a/src/main/resources/plugin.yml
+++ b/src/main/resources/plugin.yml
@@ -2,7 +2,9 @@ name: OpenShulker
 version: '${project.version}'
 main: me.entity303.openshulker.OpenShulker
 api-version: 1.14
+folia-supported: true
 authors: [Entity303]
+softdepend: [ChestSort, WorldGuard]
 commands:
   openshulker:
-    permission: "openshulker.admin"
\ No newline at end of file
+    permission: "openshulker.admin"