Implement Limits "offset" command.

Offset command have:
- set <player> <material|entity> <number> - sets the specific limit offset for material or entity.
- add <player> <material|entity> <number> - adds the specific limit offset for material or entity.
- remove <player> <material|entity> <number> - removes the specific limit offset for material or entity.
- reset <player> <material|entity> - resets limit offset for material or entity.
- view <player> <material|entity> - views the specific limit offset for material or entity.

Relates to the #149

src/main/java/world/bentobox/limits/Limits.java

@@ -12,8 +12,8 @@ import world.bentobox.bentobox.api.addons.Addon;
 import world.bentobox.bentobox.api.addons.GameModeAddon;
 import world.bentobox.bentobox.api.user.User;
 import world.bentobox.bentobox.database.objects.Island;
-import world.bentobox.limits.commands.AdminCommand;
-import world.bentobox.limits.commands.PlayerCommand;
+import world.bentobox.limits.commands.admin.AdminCommand;
+import world.bentobox.limits.commands.player.PlayerCommand;
 import world.bentobox.limits.listeners.BlockLimitsListener;
 import world.bentobox.limits.listeners.EntityLimitListener;
 import world.bentobox.limits.listeners.JoinListener;

src/main/java/world/bentobox/limits/commands/admin/AdminCommand.java

@@ -1,4 +1,4 @@
-package world.bentobox.limits.commands;
+package world.bentobox.limits.commands.admin;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -10,6 +10,8 @@ import world.bentobox.bentobox.api.commands.CompositeCommand;
 import world.bentobox.bentobox.api.user.User;
 import world.bentobox.bentobox.util.Util;
 import world.bentobox.limits.Limits;
+import world.bentobox.limits.commands.player.LimitPanel;
+
 
 /**
  * Admin command for limits
@@ -27,7 +29,9 @@ public class AdminCommand extends CompositeCommand {
     public AdminCommand(Limits addon, CompositeCommand parent) {
         super(parent, "limits");
         this.addon = addon;
-        new CalcCommand(addon, this); 
+
+        new CalcCommand(this.addon, this);
+        new OffsetCommand(this.addon, this);
     }
 
     /* (non-Javadoc)

src/main/java/world/bentobox/limits/commands/admin/CalcCommand.java

@@ -1,4 +1,4 @@
-package world.bentobox.limits.commands;
+package world.bentobox.limits.commands.admin;
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/world/bentobox/limits/commands/admin/OffsetCommand.java

@@ -0,0 +1,689 @@
+//
+// Created by BONNe
+// Copyright - 2022
+//
+
+
+package world.bentobox.limits.commands.admin;
+
+
+import com.google.common.base.Enums;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.EntityType;
+import org.eclipse.jdt.annotation.Nullable;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import world.bentobox.bentobox.api.commands.CompositeCommand;
+import world.bentobox.bentobox.api.localization.TextVariables;
+import world.bentobox.bentobox.api.user.User;
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.bentobox.util.Util;
+import world.bentobox.limits.Limits;
+import world.bentobox.limits.objects.IslandBlockCount;
+
+
+/**
+ * This command manages offsets to the player island limits.
+ */
+public class OffsetCommand extends CompositeCommand
+{
+    /**
+     * Instantiates a new Offset command.
+     *
+     * @param addon the addon
+     * @param parent the parent
+     */
+    public OffsetCommand(Limits addon, CompositeCommand parent)
+    {
+        super(parent, "offset");
+
+        new OffsetSetCommand(addon, this);
+        new OffsetAddCommand(addon, this);
+        new OffsetRemoveCommand(addon, this);
+        new OffsetResetCommand(addon, this);
+        new OffsetDisplayCommand(addon, this);
+    }
+
+
+    @Override
+    public void setup()
+    {
+        this.setOnlyPlayer(false);
+
+        this.setPermission("admin.limits.offset");
+        this.setParametersHelp("admin.limits.offset.parameters");
+        this.setDescription("admin.limits.offset.description");
+    }
+
+
+    @Override
+    public boolean execute(User user, String s, List<String> list)
+    {
+        this.showHelp(this, user);
+        return true;
+    }
+
+
+    /**
+     * This command allows setting limit offset for material or entity.
+     */
+    private static class OffsetSetCommand extends CompositeCommand
+    {
+        /**
+         * Instantiates a new Offset set command.
+         *
+         * @param addon the addon
+         * @param parent the parent
+         */
+        public OffsetSetCommand(Limits addon, CompositeCommand parent)
+        {
+            super(parent, "set");
+            this.addon = addon;
+        }
+
+
+        @Override
+        public void setup()
+        {
+            this.setOnlyPlayer(false);
+
+            this.setPermission("admin.limits.offset.set");
+            this.setParametersHelp("admin.limits.offset.set.parameters");
+            this.setDescription("admin.limits.offset.set.description");
+        }
+
+
+        @Override
+        public boolean execute(User user, String label, List<String> args)
+        {
+            if (args.size() != 3)
+            {
+                // Show help
+                this.showHelp(this, user);
+                return false;
+            }
+
+            // Get target player
+            UUID targetUUID = Util.getUUID(args.get(0));
+
+            if (targetUUID == null)
+            {
+                user.sendMessage("general.errors.unknown-player", TextVariables.NAME, args.get(0));
+                return false;
+            }
+
+            Island island = this.getIslands().getIsland(this.getWorld(), targetUUID);
+
+            if (island == null)
+            {
+                user.sendMessage("general.errors.player-has-no-island");
+                return false;
+            }
+
+            IslandBlockCount islandData = this.addon.getBlockLimitListener().getIsland(island);
+
+            // Get new offset
+            if (!Util.isInteger(args.get(2), true))
+            {
+                user.sendMessage("general.errors.must-be-a-number", TextVariables.NUMBER, args.get(2));
+                return false;
+            }
+
+            Material material = Material.matchMaterial(args.get(1));
+            EntityType entityType = matchEntity(args.get(1));
+
+            if (material == null && entityType == null)
+            {
+                user.sendMessage("admin.limits.offset.unknown", TextVariables.NAME, args.get(1));
+                return false;
+            }
+
+            int offset = Integer.parseInt(args.get(2));
+
+            if (material != null && offset == islandData.getBlockLimitOffset(material) ||
+                entityType != null && offset == islandData.getEntityLimitOffset(entityType))
+            {
+                user.sendMessage("admin.limits.offset.set.same",
+                    TextVariables.NAME,
+                    args.get(1),
+                    TextVariables.NUMBER,
+                    args.get(2));
+                return false;
+            }
+
+            if (material != null)
+            {
+                islandData.setBlockLimitsOffset(material, offset);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.set.success",
+                    TextVariables.NUMBER, String.valueOf(offset),
+                    TextVariables.NAME, material.name());
+            }
+            else
+            {
+                islandData.setEntityLimitsOffset(entityType, offset);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.set.success",
+                    TextVariables.NUMBER, String.valueOf(offset),
+                    TextVariables.NAME, entityType.name());
+            }
+
+            return true;
+        }
+
+
+        @Override
+        public Optional<List<String>> tabComplete(User user, String alias, List<String> args)
+        {
+            return OffsetCommand.craftTabComplete(user, alias, args);
+        }
+
+
+        /**
+         * Instance of limits addon.
+         */
+        private final Limits addon;
+    }
+
+
+    /**
+     * This command allows increasing limit offset for material or entity.
+     */
+    private static class OffsetAddCommand extends CompositeCommand
+    {
+        /**
+         * Instantiates a new Offset add command.
+         *
+         * @param addon the addon
+         * @param parent the parent
+         */
+        public OffsetAddCommand(Limits addon, CompositeCommand parent)
+        {
+            super(parent, "add");
+            this.addon = addon;
+        }
+
+
+        @Override
+        public void setup()
+        {
+            this.setOnlyPlayer(false);
+
+            this.setPermission("admin.limits.offset.add");
+            this.setParametersHelp("admin.limits.offset.add.parameters");
+            this.setDescription("admin.limits.offset.add.description");
+        }
+
+
+        @Override
+        public boolean execute(User user, String label, List<String> args)
+        {
+            if (args.size() != 3)
+            {
+                // Show help
+                this.showHelp(this, user);
+                return false;
+            }
+
+            // Get target player
+            UUID targetUUID = Util.getUUID(args.get(0));
+
+            if (targetUUID == null)
+            {
+                user.sendMessage("general.errors.unknown-player", TextVariables.NAME, args.get(0));
+                return false;
+            }
+
+            Island island = this.getIslands().getIsland(this.getWorld(), targetUUID);
+
+            if (island == null)
+            {
+                user.sendMessage("general.errors.player-has-no-island");
+                return false;
+            }
+
+            IslandBlockCount islandData = this.addon.getBlockLimitListener().getIsland(island);
+
+            // Get new offset
+            if (!Util.isInteger(args.get(2), true) || Integer.parseInt(args.get(2)) < 0)
+            {
+                user.sendMessage("general.errors.must-be-positive-number", TextVariables.NUMBER, args.get(2));
+                return false;
+            }
+
+            Material material = Material.matchMaterial(args.get(1));
+            EntityType entityType = matchEntity(args.get(1));
+
+            if (material == null && entityType == null)
+            {
+                user.sendMessage("admin.limits.offset.unknown", TextVariables.NAME, args.get(1));
+                return false;
+            }
+
+            int offset = Integer.parseInt(args.get(2));
+
+            if (material != null)
+            {
+                offset += islandData.getBlockLimitOffset(material);
+
+                islandData.setBlockLimitsOffset(material, offset);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.add.success",
+                    TextVariables.NUMBER, String.valueOf(offset),
+                    TextVariables.NAME, material.name());
+            }
+            else
+            {
+                offset += islandData.getEntityLimitOffset(entityType);
+
+                islandData.setEntityLimitsOffset(entityType, offset);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.add.success",
+                    TextVariables.NUMBER, String.valueOf(offset),
+                    TextVariables.NAME, entityType.name());
+            }
+
+            return true;
+        }
+
+
+        @Override
+        public Optional<List<String>> tabComplete(User user, String alias, List<String> args)
+        {
+            return OffsetCommand.craftTabComplete(user, alias, args);
+        }
+
+
+        /**
+         * Instance of limits addon.
+         */
+        private final Limits addon;
+    }
+
+
+    /**
+     * This command allows reducing limit offset for material or entity.
+     */
+    private static class OffsetRemoveCommand extends CompositeCommand
+    {
+        /**
+         * Instantiates a new Offset remove command.
+         *
+         * @param addon the addon
+         * @param parent the parent
+         */
+        public OffsetRemoveCommand(Limits addon, CompositeCommand parent)
+        {
+            super(parent, "remove");
+            this.addon = addon;
+        }
+
+
+        @Override
+        public void setup()
+        {
+            this.setOnlyPlayer(false);
+
+            this.setPermission("admin.limits.offset.remove");
+            this.setParametersHelp("admin.limits.offset.remove.parameters");
+            this.setDescription("admin.limits.offset.remove.description");
+        }
+
+
+        @Override
+        public boolean execute(User user, String label, List<String> args)
+        {
+            if (args.size() != 3)
+            {
+                // Show help
+                this.showHelp(this, user);
+                return false;
+            }
+
+            // Get target player
+            UUID targetUUID = Util.getUUID(args.get(0));
+
+            if (targetUUID == null)
+            {
+                user.sendMessage("general.errors.unknown-player", TextVariables.NAME, args.get(0));
+                return false;
+            }
+
+            Island island = this.getIslands().getIsland(this.getWorld(), targetUUID);
+
+            if (island == null)
+            {
+                user.sendMessage("general.errors.player-has-no-island");
+                return false;
+            }
+
+            IslandBlockCount islandData = this.addon.getBlockLimitListener().getIsland(island);
+
+            // Get new offset
+            if (!Util.isInteger(args.get(2), true) || Integer.parseInt(args.get(2)) < 0)
+            {
+                user.sendMessage("general.errors.must-be-positive-number", TextVariables.NUMBER, args.get(2));
+                return false;
+            }
+
+            Material material = Material.matchMaterial(args.get(1));
+            EntityType entityType = matchEntity(args.get(1));
+
+            if (material == null && entityType == null)
+            {
+                user.sendMessage("admin.limits.offset.unknown", TextVariables.NAME, args.get(1));
+                return false;
+            }
+
+            int offset = Integer.parseInt(args.get(2));
+
+            if (material != null)
+            {
+                offset = islandData.getBlockLimitOffset(material) - offset;
+
+                islandData.setBlockLimitsOffset(material, offset);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.remove.success",
+                    TextVariables.NUMBER, String.valueOf(offset),
+                    TextVariables.NAME, material.name());
+            }
+            else
+            {
+                offset = islandData.getEntityLimitOffset(entityType) - offset;
+
+                islandData.setEntityLimitsOffset(entityType, offset);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.remove.success",
+                    TextVariables.NUMBER, String.valueOf(offset),
+                    TextVariables.NAME, entityType.name());
+            }
+
+            return true;
+        }
+
+
+        @Override
+        public Optional<List<String>> tabComplete(User user, String alias, List<String> args)
+        {
+            return OffsetCommand.craftTabComplete(user, alias, args);
+        }
+
+
+        /**
+         * Instance of limits addon.
+         */
+        private final Limits addon;
+    }
+
+
+    /**
+     * This command allows resetting limit offset for material or entity.
+     */
+    private static class OffsetResetCommand extends CompositeCommand
+    {
+        /**
+         * Instantiates a new Offset reset command.
+         *
+         * @param addon the addon
+         * @param parent the parent
+         */
+        public OffsetResetCommand(Limits addon, CompositeCommand parent)
+        {
+            super(parent, "reset");
+            this.addon = addon;
+        }
+
+
+        @Override
+        public void setup()
+        {
+            this.setOnlyPlayer(false);
+
+            this.setPermission("admin.limits.offset.reset");
+            this.setParametersHelp("admin.limits.offset.reset.parameters");
+            this.setDescription("admin.limits.offset.reset.description");
+        }
+
+
+        @Override
+        public boolean execute(User user, String label, List<String> args)
+        {
+            if (args.size() != 2)
+            {
+                // Show help
+                this.showHelp(this, user);
+                return false;
+            }
+
+            // Get target player
+            UUID targetUUID = Util.getUUID(args.get(0));
+
+            if (targetUUID == null)
+            {
+                user.sendMessage("general.errors.unknown-player", TextVariables.NAME, args.get(0));
+                return false;
+            }
+
+            Island island = this.getIslands().getIsland(this.getWorld(), targetUUID);
+
+            if (island == null)
+            {
+                user.sendMessage("general.errors.player-has-no-island");
+                return false;
+            }
+
+            IslandBlockCount islandData = this.addon.getBlockLimitListener().getIsland(island);
+
+            Material material = Material.matchMaterial(args.get(1));
+            EntityType entityType = matchEntity(args.get(1));
+
+            if (material == null && entityType == null)
+            {
+                user.sendMessage("admin.limits.offset.unknown", TextVariables.NAME, args.get(1));
+                return false;
+            }
+
+            if (material != null)
+            {
+                islandData.setBlockLimitsOffset(material, 0);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.reset.success",
+                    TextVariables.NAME, material.name());
+            }
+            else
+            {
+                islandData.setEntityLimitsOffset(entityType, 0);
+                islandData.setChanged();
+
+                user.sendMessage("admin.limits.offset.reset.success",
+                    TextVariables.NAME, entityType.name());
+            }
+
+            return true;
+        }
+
+
+        @Override
+        public Optional<List<String>> tabComplete(User user, String alias, List<String> args)
+        {
+            return OffsetCommand.craftTabComplete(user, alias, args);
+        }
+
+
+        /**
+         * Instance of limits addon.
+         */
+        private final Limits addon;
+    }
+
+
+    /**
+     * This command allows viewing limit offset for material or entity.
+     */
+    private static class OffsetDisplayCommand extends CompositeCommand
+    {
+        /**
+         * Instantiates a new Offset display command.
+         *
+         * @param addon the addon
+         * @param parent the parent
+         */
+        public OffsetDisplayCommand(Limits addon, CompositeCommand parent)
+        {
+            super(parent, "view", "display");
+            this.addon = addon;
+        }
+
+
+        @Override
+        public void setup()
+        {
+            this.setOnlyPlayer(false);
+
+            this.setPermission("admin.limits.offset.view");
+            this.setParametersHelp("admin.limits.offset.view.parameters");
+            this.setDescription("admin.limits.offset.view.description");
+        }
+
+
+        @Override
+        public boolean execute(User user, String label, List<String> args)
+        {
+            if (args.size() != 2)
+            {
+                // Show help
+                this.showHelp(this, user);
+                return false;
+            }
+
+            // Get target player
+            UUID targetUUID = Util.getUUID(args.get(0));
+
+            if (targetUUID == null)
+            {
+                user.sendMessage("general.errors.unknown-player", TextVariables.NAME, args.get(0));
+                return false;
+            }
+
+            Island island = this.getIslands().getIsland(this.getWorld(), targetUUID);
+
+            if (island == null)
+            {
+                user.sendMessage("general.errors.player-has-no-island");
+                return false;
+            }
+
+            IslandBlockCount islandData = this.addon.getBlockLimitListener().getIsland(island);
+
+            Material material = Material.matchMaterial(args.get(1));
+            EntityType entityType = matchEntity(args.get(1));
+
+            if (material == null && entityType == null)
+            {
+                user.sendMessage("admin.limits.offset.unknown", TextVariables.NAME, args.get(1));
+                return false;
+            }
+
+            if (material != null)
+            {
+                int offset = islandData.getBlockLimitOffset(material);
+                user.sendMessage("admin.limits.offset.view.message",
+                    TextVariables.NAME, material.name(),
+                    TextVariables.NUMBER, String.valueOf(offset));
+            }
+            else
+            {
+                int offset = islandData.getEntityLimitOffset(entityType);
+                user.sendMessage("admin.limits.offset.view.message",
+                    TextVariables.NAME, entityType.name(),
+                    TextVariables.NUMBER, String.valueOf(offset));
+            }
+
+            return true;
+        }
+
+
+        @Override
+        public Optional<List<String>> tabComplete(User user, String alias, List<String> args)
+        {
+            return OffsetCommand.craftTabComplete(user, alias, args);
+        }
+
+
+        /**
+         * Instance of limits addon.
+         */
+        private final Limits addon;
+    }
+
+
+    /**
+     * This material matches name to an entity type.
+     * @param name Name that must be matched.
+     * @return EntityType or null.
+     */
+    @Nullable
+    private static EntityType matchEntity(String name)
+    {
+        String filtered = name;
+
+        if (filtered.startsWith(NamespacedKey.MINECRAFT + ":"))
+        {
+            filtered = filtered.substring((NamespacedKey.MINECRAFT + ":").length());
+        }
+
+        filtered = filtered.toUpperCase(java.util.Locale.ENGLISH);
+        filtered = filtered.replaceAll("\\s+", "_").replaceAll("\\W", "");
+
+        return Enums.getIfPresent(EntityType.class, filtered).orNull();
+    }
+
+
+    /**
+     * This method crafts tab complete for all subcommands
+     * @param user User who runs command.
+     * @param alias Command alias.
+     * @param args List of args.
+     * @return Optional list of strings.
+     */
+    private static Optional<List<String>> craftTabComplete(User user, String alias, List<String> args)
+    {
+        String lastArg = !args.isEmpty() ? args.get(args.size() - 1) : "";
+
+        if (args.isEmpty())
+        {
+            // Don't show every player on the server. Require at least the first letter
+            return Optional.empty();
+        }
+        else if (args.size() == 4)
+        {
+            List<String> options = new ArrayList<>(Util.getOnlinePlayerList(user));
+            return Optional.of(Util.tabLimit(options, lastArg));
+        }
+        else if (args.size() == 5)
+        {
+            List<String> options = Arrays.stream(Material.values()).
+                map(Enum::name).
+                collect(Collectors.toList());
+
+            options.addAll(Arrays.stream(EntityType.values()).
+                map(Enum::name).
+                collect(Collectors.toList()));
+
+            return Optional.of(Util.tabLimit(options, lastArg));
+        }
+        else
+        {
+            return Optional.empty();
+        }
+    }
+}

src/main/java/world/bentobox/limits/commands/player/LimitPanel.java

@@ -1,4 +1,4 @@
-package world.bentobox.limits.commands;
+package world.bentobox.limits.commands.player;
 
 import java.util.Map;
 import java.util.UUID;

src/main/java/world/bentobox/limits/commands/player/LimitTab.java

@@ -1,4 +1,4 @@
-package world.bentobox.limits.commands;
+package world.bentobox.limits.commands.player;
 
 import java.util.*;
 import java.util.Map.Entry;

src/main/java/world/bentobox/limits/commands/player/PlayerCommand.java

@@ -1,4 +1,4 @@
-package world.bentobox.limits.commands;
+package world.bentobox.limits.commands.player;
 
 import java.util.List;
 

src/main/java/world/bentobox/limits/commands/player/RecountCommand.java

@@ -1,4 +1,4 @@
-package world.bentobox.limits.commands;
+package world.bentobox.limits.commands.player;
 
 import java.util.List;
 

src/main/resources/locales/en-US.yml

@@ -20,7 +20,32 @@ admin:
          parameters: "<player>"
          description: "recalculate the island limits for player"
          finished: "&a Island recalc finished successfully!"
-
+      offset:
+        unknown: "&c Unknown material or entity [name]."
+        main:
+          parameters: ""
+          description: "allows to manage limits offsets for materials and entities"
+        set:
+          parameters: "<player> <material|entity> <number>"
+          description: "sets new offset for material or entity limit"
+          success: "&a Limit offset for [name] is set to [number]."
+          same: "&c Limit offset for [name] is already [number]."
+        add:
+          parameters: "<player> <material|entity> <number>"
+          description: "adds offset for material or entity limit"
+          success: "&a Limit offset for [name] is increased till [number]."
+        remove:
+          parameters: "<player> <material|entity> <number>"
+          description: "reduces offset for material or entity limit"
+          success: "&a Limit offset for [name] is reduced till [number]."
+        reset:
+          parameters: "<player> <material|entity>"
+          description: "removes offset for material or entity"
+          success: "&a Limit offset for [name] is set to 0."
+        view:
+          parameters: "<player> <material|entity>"
+          description: "displays offset for material or entity"
+          message: "&a [name] offset is set to [number]."
 island:
   limits:
     description: "show your island limits"

src/test/java/world/bentobox/limits/commands/player/LimitTabTest.java

@@ -1,4 +1,4 @@
-package world.bentobox.limits.commands;
+package world.bentobox.limits.commands.player;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;