From f635c07ead208cbf3f964cea1b50c82e41dbfdd2 Mon Sep 17 00:00:00 2001 From: Katorly <70022443+katorly@users.noreply.github.com> Date: Fri, 31 Dec 2021 19:15:02 +0800 Subject: [PATCH 01/28] Update zh-CN translation for Limits --- src/main/resources/locales/zh-CN.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/resources/locales/zh-CN.yml b/src/main/resources/locales/zh-CN.yml index f0a598e..55f5d0b 100644 --- a/src/main/resources/locales/zh-CN.yml +++ b/src/main/resources/locales/zh-CN.yml @@ -30,3 +30,6 @@ island: no-limits: "&c此世界中无限制" recount: description: "重新计数岛屿限制" + now-recounting: "&b 开始重新计算. 可能需要一定的时间, 请稍等......" + in-progress: "&c 重新计算岛屿限制中. 请稍等......" + time-out: "&c 重新计算超时. 岛屿太大了吗?" From 8d56a4078af008f5b324b95fac19f0ca785fabcf Mon Sep 17 00:00:00 2001 From: tastybento Date: Sun, 2 Jan 2022 11:16:18 -0800 Subject: [PATCH 02/28] Version 1.19.1 --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 47937f0..4bcf5e1 100644 --- a/pom.xml +++ b/pom.xml @@ -64,7 +64,7 @@ -LOCAL - 1.19.0 + 1.19.1 BentoBoxWorld_Limits bentobox-world https://sonarcloud.io From 886c6c5fa5b1e8f7aa9b988189eb551cfc7e7582 Mon Sep 17 00:00:00 2001 From: tastybento Date: Sun, 2 Jan 2022 11:16:27 -0800 Subject: [PATCH 03/28] Remove debug --- .../limits/listeners/JoinListener.java | 50 +++++++++++++------ 1 file changed, 34 insertions(+), 16 deletions(-) diff --git a/src/main/java/world/bentobox/limits/listeners/JoinListener.java b/src/main/java/world/bentobox/limits/listeners/JoinListener.java index b24ff22..1e0830e 100644 --- a/src/main/java/world/bentobox/limits/listeners/JoinListener.java +++ b/src/main/java/world/bentobox/limits/listeners/JoinListener.java @@ -18,9 +18,7 @@ import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.permissions.PermissionAttachmentInfo; import org.eclipse.jdt.annotation.NonNull; -import org.eclipse.jdt.annotation.Nullable; -import world.bentobox.bentobox.BentoBox; import world.bentobox.bentobox.api.events.island.IslandEvent; import world.bentobox.bentobox.api.events.island.IslandEvent.Reason; import world.bentobox.bentobox.api.events.team.TeamSetownerEvent; @@ -84,19 +82,25 @@ public class JoinListener implements Listener { } // Get the value int value = Integer.parseInt(split[4]); + addon.log("Setting login limit via perm for " + player.getName() + "..."); + // Fire perm check event LimitsPermCheckEvent l = new LimitsPermCheckEvent(player, islandId, ibc, entgroup, et, m, value); Bukkit.getPluginManager().callEvent(l); - if (l.isCancelled()) continue; + if (l.isCancelled()) { + addon.log("Permissions not set because another addon/plugin canceled setting."); + continue; + } // Use event values ibc = l.getIbc(); + // Make an ibc if required + if (ibc == null) { + ibc = new IslandBlockCount(islandId, gameMode); + } // Run null checks and set ibc runNullCheckAndSet(ibc, l); } // Check removed permissions - if (ibc == null) { - BentoBox.getInstance().logDebug("IBC is still null"); - } // If any changes have been made then store it - don't make files unless they are needed if (ibc != null) addon.getBlockLimitListener().setIsland(islandId, ibc); } @@ -122,30 +126,37 @@ public class JoinListener implements Listener { return false; } - private void runNullCheckAndSet(@Nullable IslandBlockCount ibc, @NonNull LimitsPermCheckEvent l) { - if (ibc == null) { - return; - } + private void runNullCheckAndSet(@NonNull IslandBlockCount ibc, @NonNull LimitsPermCheckEvent l) { EntityGroup entgroup = l.getEntityGroup(); EntityType et = l.getEntityType(); Material m = l.getMaterial(); int value = l.getValue(); if (entgroup != null) { // Entity group limit - ibc.setEntityGroupLimit(entgroup.getName(), Math.max(ibc.getEntityGroupLimit(entgroup.getName()), value)); + int v = Math.max(ibc.getEntityGroupLimit(entgroup.getName()), value); + ibc.setEntityGroupLimit(entgroup.getName(), v); + addon.log("Setting group limit " + entgroup.getName() + " " + v); } else if (et != null && m == null) { // Entity limit - ibc.setEntityLimit(et, Math.max(ibc.getEntityLimit(et), value)); + int v = Math.max(ibc.getEntityLimit(et), value); + ibc.setEntityLimit(et, v); + addon.log("Setting entity limit " + et + " " + v); } else if (m != null && et == null) { - // Material limit - ibc.setBlockLimit(m, Math.max(ibc.getBlockLimit(m), value)); + // Block limit + int v = Math.max(ibc.getBlockLimit(m), value); + addon.log("Setting block limit " + m + " " + v); + ibc.setBlockLimit(m, v); } else { if (m != null && m.isBlock()) { + int v = Math.max(ibc.getBlockLimit(m), value); + addon.log("Setting block limit " + m + " " + v); // Material limit - ibc.setBlockLimit(m, Math.max(ibc.getBlockLimit(m), value)); + ibc.setBlockLimit(m, v); } else if (et != null){ + int v = Math.max(ibc.getEntityLimit(et), value); + addon.log("Setting entity limit " + et + " " + v); // This is an entity setting - ibc.setEntityLimit(et, Math.max(ibc.getEntityLimit(et), value)); + ibc.setEntityLimit(et, v); } } @@ -191,6 +202,13 @@ public class JoinListener implements Listener { }); } + /** + * Fire event so other addons can cancel this permissions change + * @param player player + * @param islandId island id + * @param ibc island block count + * @return true if canceled + */ private boolean joinEventCheck(Player player, String islandId, IslandBlockCount ibc) { // Fire event, so other addons can cancel this permissions change LimitsJoinPermCheckEvent e = new LimitsJoinPermCheckEvent(player, islandId, ibc); From 78e02b6196952a6df5fc55008d710d38c0c52195 Mon Sep 17 00:00:00 2001 From: tastybento Date: Sun, 2 Jan 2022 11:55:10 -0800 Subject: [PATCH 04/28] Ignore groups if they are unknown. --- src/main/java/world/bentobox/limits/commands/LimitTab.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/world/bentobox/limits/commands/LimitTab.java b/src/main/java/world/bentobox/limits/commands/LimitTab.java index 9894934..d6122ee 100644 --- a/src/main/java/world/bentobox/limits/commands/LimitTab.java +++ b/src/main/java/world/bentobox/limits/commands/LimitTab.java @@ -103,8 +103,11 @@ public class LimitTab implements Tab { .filter(e -> groupByName.containsKey(e.getKey())) .forEach(e -> groupMap.put(groupByName.get(e.getKey()), e.getValue())); // Update the group map for each group limit offset. If the value already exists add it - ibc.getEntityGroupLimitsOffset().forEach((key, value) -> - groupMap.put(groupByName.get(key), (groupMap.getOrDefault(groupByName.get(key), 0) + value))); + ibc.getEntityGroupLimitsOffset().forEach((key, value) -> { + if (groupByName.get(key) != null) { + groupMap.put(groupByName.get(key), (groupMap.getOrDefault(groupByName.get(key), 0) + value)); + } + }); groupMap.forEach((v, limit) -> { PanelItemBuilder pib = new PanelItemBuilder(); EntityType k = v.getTypes().iterator().next(); From d038269f8ca34962c074dba43e739d39d5d84353 Mon Sep 17 00:00:00 2001 From: tastybento Date: Sun, 2 Jan 2022 12:45:16 -0800 Subject: [PATCH 05/28] Add getIsland method --- .../limits/listeners/BlockLimitsListener.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java index 31463c8..1cb80b7 100644 --- a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java +++ b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java @@ -38,12 +38,14 @@ import org.bukkit.event.block.LeavesDecayEvent; import org.bukkit.event.entity.EntityChangeBlockEvent; import org.bukkit.event.entity.EntityExplodeEvent; import org.bukkit.event.player.PlayerInteractEvent; +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import world.bentobox.bentobox.api.events.island.IslandDeleteEvent; import world.bentobox.bentobox.api.localization.TextVariables; import world.bentobox.bentobox.api.user.User; import world.bentobox.bentobox.database.Database; +import world.bentobox.bentobox.database.objects.Island; import world.bentobox.bentobox.util.Util; import world.bentobox.limits.Limits; import world.bentobox.limits.objects.IslandBlockCount; @@ -463,4 +465,14 @@ public class BlockLimitsListener implements Listener { return islandCountMap.get(islandId); } + /** + * Get the island block count for island and make one if it does not exist + * @param island island + * @return island block count + */ + @NonNull + public IslandBlockCount getIsland(Island island) { + return islandCountMap.computeIfAbsent(island.getUniqueId(), k -> new IslandBlockCount(k, island.getGameMode())); + } + } From 360ba0b2dedb4ba39c1d5375f97a61202f2b1217 Mon Sep 17 00:00:00 2001 From: tastybento Date: Sun, 2 Jan 2022 16:31:02 -0800 Subject: [PATCH 06/28] Rework how offsets are used. https://github.com/BentoBoxWorld/Upgrades/issues/40 https://github.com/BentoBoxWorld/Limits/issues/117 --- .../limits/listeners/BlockLimitsListener.java | 19 ++++++--- .../limits/listeners/EntityLimitListener.java | 38 ++++++++++++------ .../limits/objects/IslandBlockCount.java | 39 ++++++++++++++++--- 3 files changed, 72 insertions(+), 24 deletions(-) diff --git a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java index 1cb80b7..0fa02b9 100644 --- a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java +++ b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java @@ -209,6 +209,13 @@ public class BlockLimitsListener implements Listener { notify(e, User.getInstance(e.getPlayer()), process(e.getBlock(), true), e.getBlock().getType()); } + /** + * Cancel the event and notify the user of failure + * @param e event + * @param user user + * @param limit maximum limit allowed + * @param m material + */ private void notify(Cancellable e, User user, int limit, Material m) { if (limit > -1) { user.notify("block-limits.hit-limit", @@ -389,18 +396,18 @@ public class BlockLimitsListener implements Listener { */ private int checkLimit(World w, Material m, String id) { // Check island limits - IslandBlockCount island = islandCountMap.get(id); - if (island.isBlockLimited(m)) { - return island.isAtLimit(m) ? island.getBlockLimit(m) : -1; + IslandBlockCount ibc = islandCountMap.get(id); + if (ibc.isBlockLimited(m)) { + return ibc.isAtLimit(m) ? ibc.getBlockLimit(m) + ibc.getBlockLimitOffset(m) : -1; } // Check specific world limits if (worldLimitMap.containsKey(w) && worldLimitMap.get(w).containsKey(m)) { // Material is overridden in world - return island.isAtLimit(m, worldLimitMap.get(w).get(m)) ? worldLimitMap.get(w).get(m) : -1; + return ibc.isAtLimit(m, worldLimitMap.get(w).get(m)) ? worldLimitMap.get(w).get(m) + ibc.getBlockLimitOffset(m) : -1; } // Check default limit map - if (defaultLimitMap.containsKey(m) && island.isAtLimit(m, defaultLimitMap.get(m))) { - return defaultLimitMap.get(m); + if (defaultLimitMap.containsKey(m) && ibc.isAtLimit(m, defaultLimitMap.get(m))) { + return defaultLimitMap.get(m) + ibc.getBlockLimitOffset(m); } // No limit return -1; diff --git a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java index 32bacac..cf5a4f1 100644 --- a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java +++ b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java @@ -30,6 +30,7 @@ import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason; import org.bukkit.event.entity.EntityBreedEvent; import org.bukkit.event.hanging.HangingPlaceEvent; import org.bukkit.event.vehicle.VehicleCreateEvent; +import org.eclipse.jdt.annotation.Nullable; import world.bentobox.bentobox.BentoBox; import world.bentobox.bentobox.api.localization.TextVariables; @@ -39,6 +40,7 @@ import world.bentobox.bentobox.util.Util; import world.bentobox.limits.Limits; import world.bentobox.limits.Settings; import world.bentobox.limits.Settings.EntityGroup; +import world.bentobox.limits.objects.IslandBlockCount; public class EntityLimitListener implements Listener { private static final String MOD_BYPASS = "mod.bypass"; @@ -369,11 +371,16 @@ public class EntityLimitListener implements Listener { // Check island settings first int limitAmount = -1; Map groupsLimits = new HashMap<>(); - if (addon.getBlockLimitListener().getIsland(island.getUniqueId()) != null) { - limitAmount = addon.getBlockLimitListener().getIsland(island.getUniqueId()).getEntityLimit(ent.getType()); + + @Nullable + IslandBlockCount ibc = addon.getBlockLimitListener().getIsland(island.getUniqueId()); + if (ibc != null) { + // Get the limit amount for this type + limitAmount = ibc.getEntityLimit(ent.getType()); + // Handle entity groups List groupdefs = addon.getSettings().getGroupLimits().getOrDefault(ent.getType(), new ArrayList<>()); groupdefs.forEach(def -> { - int limit = addon.getBlockLimitListener().getIsland(island.getUniqueId()).getEntityGroupLimit(def.getName()); + int limit = ibc.getEntityGroupLimit(def.getName()); if (limit >= 0) groupsLimits.put(def, limit); }); @@ -382,12 +389,15 @@ public class EntityLimitListener implements Listener { if (limitAmount < 0 && addon.getSettings().getLimits().containsKey(ent.getType())) { limitAmount = addon.getSettings().getLimits().get(ent.getType()); } + // Group limits if (addon.getSettings().getGroupLimits().containsKey(ent.getType())) { addon.getSettings().getGroupLimits().getOrDefault(ent.getType(), new ArrayList<>()).stream() .filter(group -> !groupsLimits.containsKey(group) || groupsLimits.get(group) > group.getLimit()) .forEach(group -> groupsLimits.put(group, group.getLimit())); } - if (limitAmount < 0 && groupsLimits.isEmpty()) return new AtLimitResult(); + if (limitAmount < 0 && groupsLimits.isEmpty()) { + return new AtLimitResult(); + } // We have to count the entities if (limitAmount >= 0) @@ -396,14 +406,16 @@ public class EntityLimitListener implements Listener { .filter(e -> e.getType().equals(ent.getType())) .filter(e -> island.inIslandSpace(e.getLocation())) .count(); - if (count >= limitAmount) { - return new AtLimitResult(ent.getType(), limitAmount); + int max = limitAmount + ibc.getEntityLimitOffset(ent.getType()); + if (count >= max) { + return new AtLimitResult(ent.getType(), max); } } - // Merge in any permission-based limits - if (addon.getBlockLimitListener().getIsland(island.getUniqueId()) != null) { - Map groupbyname = groupsLimits.keySet().stream().collect(Collectors.toMap(EntityGroup::getName, e -> e)); - addon.getBlockLimitListener().getIsland(island.getUniqueId()).getEntityGroupLimits().entrySet().stream() + // Group limits + if (ibc != null) { + Map groupbyname = groupsLimits.keySet().stream() + .collect(Collectors.toMap(EntityGroup::getName, e -> e)); + ibc.getEntityGroupLimits().entrySet().stream() .filter(e -> groupbyname.containsKey(e.getKey())) .forEach(e -> groupsLimits.put(groupbyname.get(e.getKey()), e.getValue())); } @@ -414,8 +426,10 @@ public class EntityLimitListener implements Listener { int count = (int) ent.getWorld().getEntities().stream() .filter(e -> group.getKey().contains(e.getType())) .filter(e -> island.inIslandSpace(e.getLocation())).count(); - if (count >= group.getValue()) - return new AtLimitResult(group.getKey(), group.getValue()); + int max = group.getValue() + ibc.getEntityGroupLimitOffset(group.getKey().getName()); + if (count >= max) { + return new AtLimitResult(group.getKey(), max); + } } return new AtLimitResult(); } diff --git a/src/main/java/world/bentobox/limits/objects/IslandBlockCount.java b/src/main/java/world/bentobox/limits/objects/IslandBlockCount.java index 69088cb..8cc137e 100644 --- a/src/main/java/world/bentobox/limits/objects/IslandBlockCount.java +++ b/src/main/java/world/bentobox/limits/objects/IslandBlockCount.java @@ -127,7 +127,7 @@ public class IslandBlockCount implements DataObject { * @return true if count is >= limit */ public boolean isAtLimit(Material material, int limit) { - return blockCounts.getOrDefault(material, 0) >= limit; + return blockCounts.getOrDefault(material, 0) >= limit + this.getBlockLimitOffset(material); } /** @@ -137,7 +137,7 @@ public class IslandBlockCount implements DataObject { */ public boolean isAtLimit(Material m) { // Check island limits first - return blockLimits.containsKey(m) && blockCounts.getOrDefault(m, 0) >= getBlockLimit(m); + return blockLimits.containsKey(m) && blockCounts.getOrDefault(m, 0) >= getBlockLimit(m) + this.getBlockLimitOffset(m); } public boolean isBlockLimited(Material m) { @@ -164,8 +164,17 @@ public class IslandBlockCount implements DataObject { * @param m - material * @return limit or -1 for unlimited */ - public Integer getBlockLimit(Material m) { - return blockLimits.getOrDefault(m, -1) + getBlockLimitsOffset().getOrDefault(m, 0); + public int getBlockLimit(Material m) { + return blockLimits.getOrDefault(m, -1); + } + + /** + * Get the block offset for this material for this island + * @param m - material + * @return offset + */ + public int getBlockLimitOffset(Material m) { + return getBlockLimitsOffset().getOrDefault(m, 0); } /** @@ -228,7 +237,16 @@ public class IslandBlockCount implements DataObject { * @return limit or -1 for unlimited */ public int getEntityLimit(EntityType t) { - return entityLimits.getOrDefault(t, -1) + getEntityLimitsOffset().getOrDefault(t, 0); + return entityLimits.getOrDefault(t, -1); + } + + /** + * Get the limit offset for an entity type + * @param t - entity type + * @return offset + */ + public int getEntityLimitOffset(EntityType t) { + return getEntityLimitsOffset().getOrDefault(t, 0); } /** @@ -270,7 +288,16 @@ public class IslandBlockCount implements DataObject { * @return limit or -1 for unlimited */ public int getEntityGroupLimit(String name) { - return entityGroupLimits.getOrDefault(name, -1) + getEntityGroupLimitsOffset().getOrDefault(name, 0); + return entityGroupLimits.getOrDefault(name, -1); + } + + /** + * Get the offset for an entity group + * @param name - entity group + * @return offset + */ + public int getEntityGroupLimitOffset(String name) { + return getEntityGroupLimitsOffset().getOrDefault(name, 0); } /** From fe0e935e146dbcbc8386c22a849fb1274fd04907 Mon Sep 17 00:00:00 2001 From: Alberto Date: Sun, 9 Jan 2022 20:50:34 +0100 Subject: [PATCH 07/28] Fixes Villager limit --- .../world/bentobox/limits/listeners/EntityLimitListener.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java index cf5a4f1..0ac5f53 100644 --- a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java +++ b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java @@ -17,6 +17,7 @@ import org.bukkit.World; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; import org.bukkit.entity.Animals; +import org.bukkit.entity.Villager; import org.bukkit.entity.Entity; import org.bukkit.entity.EntityType; import org.bukkit.entity.LivingEntity; @@ -109,7 +110,7 @@ public class EntityLimitListener implements Listener { justSpawned.remove(e.getEntity().getUniqueId()); return; } - if (e.getSpawnReason().equals(SpawnReason.SHOULDER_ENTITY) || e.getSpawnReason().equals(SpawnReason.BREEDING)) { + if (e.getSpawnReason().equals(SpawnReason.SHOULDER_ENTITY) || (!(e.getEntity() instanceof Villager ) && e.getSpawnReason().equals(SpawnReason.BREEDING))) { // Special case - do nothing - jumping around spawns parrots as they drop off player's shoulder // Ignore breeding because it's handled in the EntityBreedEvent listener return; From e8dffc76f55a00d4a933c690057ce57a7576602a Mon Sep 17 00:00:00 2001 From: tastybento Date: Fri, 21 Jan 2022 18:53:45 -0800 Subject: [PATCH 08/28] Avoid NPE with ibc https://github.com/BentoBoxWorld/Limits/issues/157 --- .../world/bentobox/limits/listeners/EntityLimitListener.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java index cf5a4f1..18d6543 100644 --- a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java +++ b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java @@ -406,7 +406,7 @@ public class EntityLimitListener implements Listener { .filter(e -> e.getType().equals(ent.getType())) .filter(e -> island.inIslandSpace(e.getLocation())) .count(); - int max = limitAmount + ibc.getEntityLimitOffset(ent.getType()); + int max = limitAmount + (ibc == null ? 0 : ibc.getEntityLimitOffset(ent.getType())); if (count >= max) { return new AtLimitResult(ent.getType(), max); } @@ -426,7 +426,7 @@ public class EntityLimitListener implements Listener { int count = (int) ent.getWorld().getEntities().stream() .filter(e -> group.getKey().contains(e.getType())) .filter(e -> island.inIslandSpace(e.getLocation())).count(); - int max = group.getValue() + ibc.getEntityGroupLimitOffset(group.getKey().getName()); + int max = group.getValue() + + (ibc == null ? 0 : ibc.getEntityGroupLimitOffset(group.getKey().getName())); if (count >= max) { return new AtLimitResult(group.getKey(), max); } From d7bff1df7deeb308b9d0f90d7e5c395b34d687ca Mon Sep 17 00:00:00 2001 From: YellowZaki Date: Fri, 25 Mar 2022 17:29:27 +0100 Subject: [PATCH 09/28] Turned into a Pladdon --- pom.xml | 22 ++++++++++------- .../world/bentobox/limits/LimitsPladdon.java | 24 +++++++++++++++++++ .../limits/listeners/EntityLimitListener.java | 2 +- 3 files changed, 39 insertions(+), 9 deletions(-) create mode 100644 src/main/java/world/bentobox/limits/LimitsPladdon.java diff --git a/pom.xml b/pom.xml index 4bcf5e1..248b1ad 100644 --- a/pom.xml +++ b/pom.xml @@ -135,6 +135,12 @@ ${spigot.version} provided + + org.spigotmc + plugin-annotations + 1.2.3-SNAPSHOT + provided + org.mockito @@ -196,14 +202,6 @@ maven-resources-plugin 3.1.0 - - org.apache.maven.plugins - maven-compiler-plugin - 3.7.0 - - ${java.version} - - org.apache.maven.plugins maven-surefire-plugin @@ -272,6 +270,14 @@ + + org.apache.maven.plugins + maven-compiler-plugin + 3.7.0 + + ${java.version} + + diff --git a/src/main/java/world/bentobox/limits/LimitsPladdon.java b/src/main/java/world/bentobox/limits/LimitsPladdon.java new file mode 100644 index 0000000..8bc79be --- /dev/null +++ b/src/main/java/world/bentobox/limits/LimitsPladdon.java @@ -0,0 +1,24 @@ +package world.bentobox.limits; + +import org.bukkit.plugin.java.annotation.dependency.Dependency; +import org.bukkit.plugin.java.annotation.plugin.ApiVersion; +import org.bukkit.plugin.java.annotation.plugin.Plugin; + +import world.bentobox.bentobox.api.addons.Addon; +import world.bentobox.bentobox.api.addons.Pladdon; + +/** + * + * @author YellowZaki + */ + +@Plugin(name="Pladdon", version="1.0") +@ApiVersion(ApiVersion.Target.v1_16) +@Dependency(value = "BentoBox") +public class LimitsPladdon extends Pladdon { + + @Override + public Addon getAddon() { + return new Limits(); + } +} diff --git a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java index 0ac5f53..1453a09 100644 --- a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java +++ b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java @@ -91,7 +91,7 @@ public class EntityLimitListener implements Listener { public void onBreed(final EntityBreedEvent e) { if (addon.inGameModeWorld(e.getEntity().getWorld()) && e.getBreeder() != null - && e.getBreeder() instanceof Player p + && (e.getBreeder() instanceof Player p) && !(p.isOp() || p.hasPermission(addon.getPlugin().getIWM().getPermissionPrefix(e.getEntity().getWorld()) + MOD_BYPASS)) && !checkLimit(e, e.getEntity(), SpawnReason.BREEDING, false) && e.getFather() instanceof Animals f && e.getMother() instanceof Animals m) { From b459f8bdb5a8a15e3571a4dd59267f604bc1bed3 Mon Sep 17 00:00:00 2001 From: BONNe Date: Sun, 27 Mar 2022 14:43:31 +0300 Subject: [PATCH 10/28] Fixes wrong placeholder value #159 Placeholder value did not check default and world limits. It used just island limits that are assigned via permissions. This commit should fix it. --- src/main/java/world/bentobox/limits/Limits.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/world/bentobox/limits/Limits.java b/src/main/java/world/bentobox/limits/Limits.java index 18c9798..c54a306 100644 --- a/src/main/java/world/bentobox/limits/Limits.java +++ b/src/main/java/world/bentobox/limits/Limits.java @@ -191,11 +191,11 @@ public class Limits extends Addon { if (is == null) { return LIMIT_NOT_SET; } - @Nullable IslandBlockCount ibc = getBlockLimitListener().getIsland(is.getUniqueId()); - if (ibc == null) { - return LIMIT_NOT_SET; - } - int limit = ibc.getBlockLimit(m); + + int limit = this.getBlockLimitListener(). + getMaterialLimits(is.getWorld(), is.getUniqueId()). + getOrDefault(m, -1); + return limit == -1 ? LIMIT_NOT_SET : String.valueOf(limit); } From 5fd461ddea1f103bc3217d16e826efbd39ac23b1 Mon Sep 17 00:00:00 2001 From: BONNe Date: Sun, 27 Mar 2022 14:45:43 +0300 Subject: [PATCH 11/28] Add limits offsets to the GUI and Placeholder Offsets were not added to the GUI and Placeholder value. Part of #159 --- .../bentobox/limits/listeners/BlockLimitsListener.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java index 0fa02b9..1f5742b 100644 --- a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java +++ b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java @@ -431,7 +431,12 @@ public class BlockLimitsListener implements Listener { } // Island if (islandCountMap.containsKey(id)) { - result.putAll(islandCountMap.get(id).getBlockLimits()); + IslandBlockCount islandBlockCount = islandCountMap.get(id); + result.putAll(islandBlockCount.getBlockLimits()); + + // Add offsets to the every limit. + islandBlockCount.getBlockLimitsOffset().forEach((material, offset) -> + result.put(material, result.getOrDefault(material, 0) + offset)); } return result; } From 782150f0f4e2a3f2ccea12d285d3fd01231b3fb1 Mon Sep 17 00:00:00 2001 From: BONNe Date: Sun, 27 Mar 2022 20:12:15 +0300 Subject: [PATCH 12/28] Fixes offset duplication in Limits Panel --- src/main/java/world/bentobox/limits/commands/LimitTab.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/world/bentobox/limits/commands/LimitTab.java b/src/main/java/world/bentobox/limits/commands/LimitTab.java index d6122ee..4e7fa74 100644 --- a/src/main/java/world/bentobox/limits/commands/LimitTab.java +++ b/src/main/java/world/bentobox/limits/commands/LimitTab.java @@ -185,7 +185,7 @@ public class LimitTab implements Tab { pib.icon(B2M.getOrDefault(en.getKey(), en.getKey())); int count = ibc == null ? 0 : ibc.getBlockCounts().getOrDefault(en.getKey(), 0); - int value = en.getValue() + (ibc == null ? 0 : ibc.getBlockLimitsOffset().getOrDefault(en.getKey(), 0)); + int value = en.getValue(); String color = count >= value ? user.getTranslation("island.limits.max-color") : user.getTranslation("island.limits.regular-color"); pib.description(color + user.getTranslation("island.limits.block-limit-syntax", From be3554bf8cd6a11203fc74a20d114dbe2e68d793 Mon Sep 17 00:00:00 2001 From: BONNe Date: Mon, 28 Mar 2022 19:04:15 +0300 Subject: [PATCH 13/28] Implement Limits "offset" command. Offset command have: - set - sets the specific limit offset for material or entity. - add - adds the specific limit offset for material or entity. - remove - removes the specific limit offset for material or entity. - reset - resets limit offset for material or entity. - view - views the specific limit offset for material or entity. Relates to the #149 --- .../java/world/bentobox/limits/Limits.java | 4 +- .../commands/{ => admin}/AdminCommand.java | 8 +- .../commands/{ => admin}/CalcCommand.java | 2 +- .../limits/commands/admin/OffsetCommand.java | 689 ++++++++++++++++++ .../commands/{ => player}/LimitPanel.java | 2 +- .../commands/{ => player}/LimitTab.java | 2 +- .../commands/{ => player}/PlayerCommand.java | 2 +- .../commands/{ => player}/RecountCommand.java | 2 +- src/main/resources/locales/en-US.yml | 27 +- .../commands/{ => player}/LimitTabTest.java | 2 +- 10 files changed, 729 insertions(+), 11 deletions(-) rename src/main/java/world/bentobox/limits/commands/{ => admin}/AdminCommand.java (92%) rename src/main/java/world/bentobox/limits/commands/{ => admin}/CalcCommand.java (98%) create mode 100644 src/main/java/world/bentobox/limits/commands/admin/OffsetCommand.java rename src/main/java/world/bentobox/limits/commands/{ => player}/LimitPanel.java (98%) rename src/main/java/world/bentobox/limits/commands/{ => player}/LimitTab.java (99%) rename src/main/java/world/bentobox/limits/commands/{ => player}/PlayerCommand.java (96%) rename src/main/java/world/bentobox/limits/commands/{ => player}/RecountCommand.java (98%) rename src/test/java/world/bentobox/limits/commands/{ => player}/LimitTabTest.java (98%) diff --git a/src/main/java/world/bentobox/limits/Limits.java b/src/main/java/world/bentobox/limits/Limits.java index c54a306..f75ecc9 100644 --- a/src/main/java/world/bentobox/limits/Limits.java +++ b/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; diff --git a/src/main/java/world/bentobox/limits/commands/AdminCommand.java b/src/main/java/world/bentobox/limits/commands/admin/AdminCommand.java similarity index 92% rename from src/main/java/world/bentobox/limits/commands/AdminCommand.java rename to src/main/java/world/bentobox/limits/commands/admin/AdminCommand.java index bf9bf3e..263b24e 100644 --- a/src/main/java/world/bentobox/limits/commands/AdminCommand.java +++ b/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) diff --git a/src/main/java/world/bentobox/limits/commands/CalcCommand.java b/src/main/java/world/bentobox/limits/commands/admin/CalcCommand.java similarity index 98% rename from src/main/java/world/bentobox/limits/commands/CalcCommand.java rename to src/main/java/world/bentobox/limits/commands/admin/CalcCommand.java index c4cb0ee..f7e7303 100644 --- a/src/main/java/world/bentobox/limits/commands/CalcCommand.java +++ b/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; diff --git a/src/main/java/world/bentobox/limits/commands/admin/OffsetCommand.java b/src/main/java/world/bentobox/limits/commands/admin/OffsetCommand.java new file mode 100644 index 0000000..b04b206 --- /dev/null +++ b/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 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 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> tabComplete(User user, String alias, List 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 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> tabComplete(User user, String alias, List 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 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> tabComplete(User user, String alias, List 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 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> tabComplete(User user, String alias, List 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 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> tabComplete(User user, String alias, List 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> craftTabComplete(User user, String alias, List 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 options = new ArrayList<>(Util.getOnlinePlayerList(user)); + return Optional.of(Util.tabLimit(options, lastArg)); + } + else if (args.size() == 5) + { + List 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(); + } + } +} diff --git a/src/main/java/world/bentobox/limits/commands/LimitPanel.java b/src/main/java/world/bentobox/limits/commands/player/LimitPanel.java similarity index 98% rename from src/main/java/world/bentobox/limits/commands/LimitPanel.java rename to src/main/java/world/bentobox/limits/commands/player/LimitPanel.java index e24d78d..bb2d6e2 100644 --- a/src/main/java/world/bentobox/limits/commands/LimitPanel.java +++ b/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; diff --git a/src/main/java/world/bentobox/limits/commands/LimitTab.java b/src/main/java/world/bentobox/limits/commands/player/LimitTab.java similarity index 99% rename from src/main/java/world/bentobox/limits/commands/LimitTab.java rename to src/main/java/world/bentobox/limits/commands/player/LimitTab.java index 4e7fa74..36267fc 100644 --- a/src/main/java/world/bentobox/limits/commands/LimitTab.java +++ b/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; diff --git a/src/main/java/world/bentobox/limits/commands/PlayerCommand.java b/src/main/java/world/bentobox/limits/commands/player/PlayerCommand.java similarity index 96% rename from src/main/java/world/bentobox/limits/commands/PlayerCommand.java rename to src/main/java/world/bentobox/limits/commands/player/PlayerCommand.java index 7f070f2..590b9e2 100644 --- a/src/main/java/world/bentobox/limits/commands/PlayerCommand.java +++ b/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; diff --git a/src/main/java/world/bentobox/limits/commands/RecountCommand.java b/src/main/java/world/bentobox/limits/commands/player/RecountCommand.java similarity index 98% rename from src/main/java/world/bentobox/limits/commands/RecountCommand.java rename to src/main/java/world/bentobox/limits/commands/player/RecountCommand.java index 5f31c8b..9f330b5 100644 --- a/src/main/java/world/bentobox/limits/commands/RecountCommand.java +++ b/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; diff --git a/src/main/resources/locales/en-US.yml b/src/main/resources/locales/en-US.yml index e1b9488..ba6a9da 100755 --- a/src/main/resources/locales/en-US.yml +++ b/src/main/resources/locales/en-US.yml @@ -20,7 +20,32 @@ admin: parameters: "" 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: " " + 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: " " + description: "adds offset for material or entity limit" + success: "&a Limit offset for [name] is increased till [number]." + remove: + parameters: " " + description: "reduces offset for material or entity limit" + success: "&a Limit offset for [name] is reduced till [number]." + reset: + parameters: " " + description: "removes offset for material or entity" + success: "&a Limit offset for [name] is set to 0." + view: + parameters: " " + description: "displays offset for material or entity" + message: "&a [name] offset is set to [number]." island: limits: description: "show your island limits" diff --git a/src/test/java/world/bentobox/limits/commands/LimitTabTest.java b/src/test/java/world/bentobox/limits/commands/player/LimitTabTest.java similarity index 98% rename from src/test/java/world/bentobox/limits/commands/LimitTabTest.java rename to src/test/java/world/bentobox/limits/commands/player/LimitTabTest.java index 403a7d9..ab92735 100644 --- a/src/test/java/world/bentobox/limits/commands/LimitTabTest.java +++ b/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; From 26d357fd42516d6e4defd4080f37f3bda3a1acb2 Mon Sep 17 00:00:00 2001 From: organizatsiya <59617430+organizatsiya@users.noreply.github.com> Date: Tue, 5 Jul 2022 19:10:59 +0200 Subject: [PATCH 14/28] Create fr.yml --- src/main/resources/locales/fr.yml | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 src/main/resources/locales/fr.yml diff --git a/src/main/resources/locales/fr.yml b/src/main/resources/locales/fr.yml new file mode 100644 index 0000000..d18ce42 --- /dev/null +++ b/src/main/resources/locales/fr.yml @@ -0,0 +1,31 @@ +block-limits: + hit-limit: '&c[material] limité à [number]!' +entity-limits: + hit-limit: '&c[entity] spawning limited to [number]!' +limits: + panel-title: Limites de l'île + + +admin: + limits: + main: + parameters: + description: affiche les limites de l'île pour le joueur + calc: + parameters: + description: recalcule les limites de l'île pour le joueur + finished: '&a Recomptage terminé avec succès!' + +island: + limits: + description: affichez les limites de votre île + max-color: '&c' + regular-color: '&a' + block-limit-syntax: '[number]/[limit]' + no-limits: '&cas de limites définies dans ce monde' + recount: + description: recompte les limites de votre île + now-recounting: '&b Recomptage en cours. Cela peut prendre un certain temps, veuillez patienter...' + in-progress: '&c Le recomptage de l'île est en cours. Veuillez patienter s'il vous plaît...' + time-out: '&c Time out lors du recomptage. L'île est-elle vraiment grande ?' + From f726492eae9d566622cf8a95910da08294970321 Mon Sep 17 00:00:00 2001 From: evlad Date: Tue, 5 Jul 2022 19:35:00 +0200 Subject: [PATCH 15/28] add new placeholders and BlockGrowEvent --- .../java/world/bentobox/limits/Limits.java | 60 +++++++++++++++++++ .../limits/listeners/BlockLimitsListener.java | 33 ++++------ 2 files changed, 72 insertions(+), 21 deletions(-) diff --git a/src/main/java/world/bentobox/limits/Limits.java b/src/main/java/world/bentobox/limits/Limits.java index f75ecc9..eab5559 100644 --- a/src/main/java/world/bentobox/limits/Limits.java +++ b/src/main/java/world/bentobox/limits/Limits.java @@ -7,6 +7,7 @@ import java.util.stream.Collectors; import org.bukkit.Material; import org.bukkit.World; +import org.bukkit.entity.EntityType; import org.eclipse.jdt.annotation.Nullable; import world.bentobox.bentobox.api.addons.Addon; import world.bentobox.bentobox.api.addons.GameModeAddon; @@ -138,6 +139,9 @@ public class Limits extends Addon { Arrays.stream(Material.values()) .filter(Material::isBlock) .forEach(m -> registerCountAndLimitPlaceholders(m, gm)); + + Arrays.stream(EntityType.values()) + .forEach(e -> registerCountAndLimitPlaceholders(e, gm)); } /** @@ -149,6 +153,8 @@ public class Limits extends Addon { * Placeholders: * "Limits_bskyblock_island_hopper_count" * "Limits_bskyblock_island_hopper_limit" + * "Limits_bskyblock_island_hopper_base_limit" + * "Limits_bskyblock_island_zombie_limit" * * @param m material * @param gm game mode @@ -160,6 +166,18 @@ public class Limits extends Addon { getPlugin().getPlaceholdersManager().registerPlaceholder(this, gm.getDescription().getName().toLowerCase() + "_island_" + m.toString().toLowerCase() + "_limit", user -> getLimit(user, m, gm)); + getPlugin().getPlaceholdersManager().registerPlaceholder(this, + gm.getDescription().getName().toLowerCase() + "_island_" + m.toString().toLowerCase() + "_base_limit", + user -> getBaseLimit(user, m, gm)); + } + + private void registerCountAndLimitPlaceholders(EntityType e, GameModeAddon gm) { + getPlugin().getPlaceholdersManager().registerPlaceholder(this, + gm.getDescription().getName().toLowerCase() + "_island_" + e.toString().toLowerCase() + "_limit", + user -> getLimit(user, e, gm)); + getPlugin().getPlaceholdersManager().registerPlaceholder(this, + gm.getDescription().getName().toLowerCase() + "_island_" + e.toString().toLowerCase() + "_base_limit", + user -> getBaseLimit(user, e, gm)); } /** @@ -199,4 +217,46 @@ public class Limits extends Addon { return limit == -1 ? LIMIT_NOT_SET : String.valueOf(limit); } + private String getBaseLimit(@Nullable User user, Material m, GameModeAddon gm) { + Island is = gm.getIslands().getIsland(gm.getOverWorld(), user); + if (is == null) { + return LIMIT_NOT_SET; + } + + int limit = this.getBlockLimitListener(). + getMaterialLimits(is.getWorld(), is.getUniqueId()). + getOrDefault(m, -1); + + if (limit > 0) { + limit -= this.getBlockLimitListener().getIsland(is).getBlockLimitOffset(m); + } + + return limit == -1 ? LIMIT_NOT_SET : String.valueOf(limit); + } + + private String getLimit(@Nullable User user, EntityType e, GameModeAddon gm) { + Island is = gm.getIslands().getIsland(gm.getOverWorld(), user); + if (is == null) { + return LIMIT_NOT_SET; + } + + int limit = this.getBlockLimitListener().getIsland(is).getEntityLimit(e); + if (limit < 0 && this.getSettings().getLimits().containsKey(e)) { + limit = this.getSettings().getLimits().get(e); + } + + return limit == -1 ? LIMIT_NOT_SET : String.valueOf(limit); + } + + private String getBaseLimit(@Nullable User user, EntityType e, GameModeAddon gm) { + Island is = gm.getIslands().getIsland(gm.getOverWorld(), user); + if (is == null || !this.getSettings().getLimits().containsKey(e)) { + return LIMIT_NOT_SET; + } + + int limit = this.getSettings().getLimits().get(e); + + return limit == -1 ? LIMIT_NOT_SET : String.valueOf(limit); + } + } diff --git a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java index 1f5742b..5d64bd4 100644 --- a/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java +++ b/src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java @@ -1,14 +1,6 @@ package world.bentobox.limits.listeners; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.EnumMap; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.Optional; +import java.util.*; import org.bukkit.Bukkit; import org.bukkit.Material; @@ -23,18 +15,7 @@ import org.bukkit.event.Event; 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.block.BlockBreakEvent; -import org.bukkit.event.block.BlockBurnEvent; -import org.bukkit.event.block.BlockExplodeEvent; -import org.bukkit.event.block.BlockFadeEvent; -import org.bukkit.event.block.BlockFormEvent; -import org.bukkit.event.block.BlockFromToEvent; -import org.bukkit.event.block.BlockMultiPlaceEvent; -import org.bukkit.event.block.BlockPlaceEvent; -import org.bukkit.event.block.BlockSpreadEvent; -import org.bukkit.event.block.EntityBlockFormEvent; -import org.bukkit.event.block.LeavesDecayEvent; +import org.bukkit.event.block.*; import org.bukkit.event.entity.EntityChangeBlockEvent; import org.bukkit.event.entity.EntityExplodeEvent; import org.bukkit.event.player.PlayerInteractEvent; @@ -256,6 +237,16 @@ public class BlockLimitsListener implements Listener { process(e.getBlock(), true); } + @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) + public void onBlock(BlockGrowEvent e) { + if (process(e.getNewState().getBlock(), true) > -1) { + e.setCancelled(true); + e.getBlock().getWorld().getBlockAt(e.getBlock().getLocation()).setBlockData(e.getBlock().getBlockData()); + } else { + process(e.getBlock(), false); + } + } + @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) public void onBlock(LeavesDecayEvent e) { process(e.getBlock(), false); From bc905adccbf9802f7bd79d9042043f2bc83d68be Mon Sep 17 00:00:00 2001 From: BONNe Date: Thu, 7 Jul 2022 12:05:46 +0300 Subject: [PATCH 16/28] Replace ' with " in FR locale Some text strings inside fr contained '. It resulted in a locale crash. This should fix that. --- src/main/resources/locales/fr.yml | 35 +++++++++++++++---------------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/src/main/resources/locales/fr.yml b/src/main/resources/locales/fr.yml index d18ce42..237e4e5 100644 --- a/src/main/resources/locales/fr.yml +++ b/src/main/resources/locales/fr.yml @@ -1,31 +1,30 @@ block-limits: - hit-limit: '&c[material] limité à [number]!' + hit-limit: "&c[material] limité à [number]!" entity-limits: - hit-limit: '&c[entity] spawning limited to [number]!' + hit-limit: "&c[entity] spawning limited to [number]!" limits: - panel-title: Limites de l'île + panel-title: "Limites de l'île" admin: limits: main: - parameters: - description: affiche les limites de l'île pour le joueur + parameters: "" + description: "affiche les limites de l'île pour le joueur" calc: - parameters: - description: recalcule les limites de l'île pour le joueur - finished: '&a Recomptage terminé avec succès!' + parameters: "" + description: "recalcule les limites de l'île pour le joueur" + finished: "&a Recomptage terminé avec succès!" island: limits: - description: affichez les limites de votre île - max-color: '&c' - regular-color: '&a' - block-limit-syntax: '[number]/[limit]' - no-limits: '&cas de limites définies dans ce monde' + description: "affichez les limites de votre île" + max-color: "&c" + regular-color: "&a" + block-limit-syntax: "[number]/[limit]" + no-limits: "&cas de limites définies dans ce monde" recount: - description: recompte les limites de votre île - now-recounting: '&b Recomptage en cours. Cela peut prendre un certain temps, veuillez patienter...' - in-progress: '&c Le recomptage de l'île est en cours. Veuillez patienter s'il vous plaît...' - time-out: '&c Time out lors du recomptage. L'île est-elle vraiment grande ?' - + description: "recompte les limites de votre île" + now-recounting: "&b Recomptage en cours. Cela peut prendre un certain temps, veuillez patienter..." + in-progress: "&c Le recomptage de l'île est en cours. Veuillez patienter s'il vous plaît..." + time-out: "&c Time out lors du recomptage. L'île est-elle vraiment grande?" From fdd827a29723c85f5eca547fed294c7777e83e45 Mon Sep 17 00:00:00 2001 From: wiktorm12 Date: Sat, 27 Aug 2022 12:13:10 +0000 Subject: [PATCH 17/28] Translate pl.yml via GitLocalize --- src/main/resources/locales/pl.yml | 51 +++++++++++++++++++++++-------- 1 file changed, 39 insertions(+), 12 deletions(-) diff --git a/src/main/resources/locales/pl.yml b/src/main/resources/locales/pl.yml index 3a3a6f0..abdea19 100644 --- a/src/main/resources/locales/pl.yml +++ b/src/main/resources/locales/pl.yml @@ -1,27 +1,54 @@ -# -# This is a YML file. Be careful when editing. Check your edits in a YAML checker like # -# the one at http://yaml-online-parser.appspot.com # +--- block-limits: - hit-limit: '&c[material] limitowany do [number]!' + hit-limit: "&c[material] limitowany do [number]!" entity-limits: - hit-limit: '&cSpawnowanie [entity] limitowane do [number]!' + hit-limit: "&cSpawnowanie [entity] limitowane do [number]!" limits: panel-title: Limity wysp admin: limits: main: - parameters: + parameters: "" description: pokazuje limity wysp gracza calc: - parameters: + parameters: "" description: ponownie oblicza limity wyspy dla gracza - finished: '&aPrzeliczanie zakończone!' + finished: "&aPrzeliczanie zakończone!" + offset: + unknown: "&c Nieznany materiał lub podmiot [name]." + main: + description: pozwala zarządzać limitów dla materiałów i podmiotów, + set: + parameters: " " + description: ustawia nową wartość dla limitu materiału lub encji + success: "&a Przesunięcie limitu dla [name] jest ustawione na [number]." + same: "&c Limit dla [name] jest aktualnie [number]." + add: + parameters: " " + description: dodaje przesunięcie dla limitu materiału lub potworów + success: "&a Przesunięcie limitu dla [name] jest zwiększone do [number]." + remove: + parameters: " " + description: zmniejsza offset dla limitu materiału lub podmiotu + success: "&a Limit dla bloku [name] \nzostał zmniejszony do [number]." + reset: + parameters: " " + description: usuwa wartość dla materiału lub istoty + success: "&a Limit dla [name] jest ustawione na 0." + view: + parameters: " " + description: displays offset for material or entity + message: "&a [name] wartość jest ustawiona na [number]." island: limits: description: pokazuje limity twojej wyspy - max-color: '&c' - regular-color: '&a' - block-limit-syntax: '[number]/[limit]' - no-limits: '&cBrak ustawionych limitów.' + max-color: "&c" + regular-color: "&a" + block-limit-syntax: "[number]/[limit]" + no-limits: "&cBrak ustawionych limitów." recount: description: określa limity dla twojej wyspy + now-recounting: "&b Teraz przeliczam. To może chwilę potrwać, proszę czekać..." + in-progress: "&c Trwa odzyskiwanie wyspy. Proszę czekać..." + time-out: "&c Przekroczono limit czasu podczas przeliczania. Czy wyspa jest + naprawdę duża?" From 989ebcba7b6ae409e2af2f9278504b7898111369 Mon Sep 17 00:00:00 2001 From: Piotr Skiba Date: Wed, 28 Sep 2022 00:08:05 +0200 Subject: [PATCH 18/28] disable villagers breeding when limit is reached --- .../bentobox/limits/listeners/EntityLimitListener.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java index eb1cfec..27f619b 100644 --- a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java +++ b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java @@ -16,7 +16,7 @@ import org.bukkit.Tag; import org.bukkit.World; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; -import org.bukkit.entity.Animals; +import org.bukkit.entity.Breedable; import org.bukkit.entity.Villager; import org.bukkit.entity.Entity; import org.bukkit.entity.EntityType; @@ -94,9 +94,9 @@ public class EntityLimitListener implements Listener { && (e.getBreeder() instanceof Player p) && !(p.isOp() || p.hasPermission(addon.getPlugin().getIWM().getPermissionPrefix(e.getEntity().getWorld()) + MOD_BYPASS)) && !checkLimit(e, e.getEntity(), SpawnReason.BREEDING, false) - && e.getFather() instanceof Animals f && e.getMother() instanceof Animals m) { - f.setLoveModeTicks(0); - m.setLoveModeTicks(0); + && e.getFather() instanceof Breedable f && e.getMother() instanceof Breedable m) { + f.setBreed(false); + m.setBreed(false); } } From 97006d28c112672eeffdeadb4f8798b4f1221527 Mon Sep 17 00:00:00 2001 From: evlad Date: Mon, 7 Nov 2022 02:05:09 +0100 Subject: [PATCH 19/28] huge performance boost for entity limit --- .../limits/listeners/EntityLimitListener.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java index eb1cfec..423f907 100644 --- a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java +++ b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java @@ -403,9 +403,12 @@ public class EntityLimitListener implements Listener { // We have to count the entities if (limitAmount >= 0) { - int count = (int) ent.getWorld().getEntities().stream() +// int count = (int) ent.getWorld().getEntities().stream() +// .filter(e -> e.getType().equals(ent.getType())) +// .filter(e -> island.inIslandSpace(e.getLocation())) +// .count(); + int count = (int) ent.getWorld().getNearbyEntities(island.getBoundingBox()).stream() .filter(e -> e.getType().equals(ent.getType())) - .filter(e -> island.inIslandSpace(e.getLocation())) .count(); int max = limitAmount + (ibc == null ? 0 : ibc.getEntityLimitOffset(ent.getType())); if (count >= max) { @@ -424,9 +427,12 @@ public class EntityLimitListener implements Listener { for (Map.Entry group : groupsLimits.entrySet()) { //do not use lambda if (group.getValue() < 0) continue; - int count = (int) ent.getWorld().getEntities().stream() +// int count = (int) ent.getWorld().getEntities().stream() +// .filter(e -> group.getKey().contains(e.getType())) +// .filter(e -> island.inIslandSpace(e.getLocation())).count(); + int count = (int) ent.getWorld().getNearbyEntities(island.getBoundingBox()).stream() .filter(e -> group.getKey().contains(e.getType())) - .filter(e -> island.inIslandSpace(e.getLocation())).count(); + .count(); int max = group.getValue() + + (ibc == null ? 0 : ibc.getEntityGroupLimitOffset(group.getKey().getName())); if (count >= max) { return new AtLimitResult(group.getKey(), max); From 3b6e912baec9a5fa4d2ede476aa1010656204e28 Mon Sep 17 00:00:00 2001 From: tastybento Date: Thu, 9 Feb 2023 15:20:32 -0800 Subject: [PATCH 20/28] Add ${argLine} to get jacoco coverage --- pom.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/pom.xml b/pom.xml index 248b1ad..94ef9fc 100644 --- a/pom.xml +++ b/pom.xml @@ -208,6 +208,7 @@ 3.0.0-M5 + ${argLine} --add-opens java.base/java.lang=ALL-UNNAMED --add-opens java.base/java.math=ALL-UNNAMED --add-opens java.base/java.io=ALL-UNNAMED From 69ded8fc3e88538e8d8e2f3002aa5c65269c11ba Mon Sep 17 00:00:00 2001 From: tastybento Date: Sat, 18 Mar 2023 17:37:49 -0400 Subject: [PATCH 21/28] Add [gamemode].mod.bypass to list of perms in addon.yml --- src/main/resources/addon.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/resources/addon.yml b/src/main/resources/addon.yml index 201c10d..e5d8fcb 100755 --- a/src/main/resources/addon.yml +++ b/src/main/resources/addon.yml @@ -5,7 +5,7 @@ api-version: 1.16.5 authors: tastybento -softdepend: AcidIsland, BSkyBlock, CaveBlock +softdepend: AcidIsland, BSkyBlock, CaveBlock, AOneBlock, SkyGrid permissions: '[gamemode].limits.player.limits': @@ -17,3 +17,6 @@ permissions: '[gamemode].limits.admin.limits': description: Player can use admin limits command default: op + '[gamemode].mod.bypass': + description: Player can bypass limits + default: op From f0727586a32beca1156181ddc5129c59ae72d49d Mon Sep 17 00:00:00 2001 From: tastybento Date: Sat, 25 Mar 2023 09:54:26 -0700 Subject: [PATCH 22/28] Update annotations --- src/main/java/world/bentobox/limits/LimitsPladdon.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/main/java/world/bentobox/limits/LimitsPladdon.java b/src/main/java/world/bentobox/limits/LimitsPladdon.java index 8bc79be..3a1eac0 100644 --- a/src/main/java/world/bentobox/limits/LimitsPladdon.java +++ b/src/main/java/world/bentobox/limits/LimitsPladdon.java @@ -1,6 +1,5 @@ package world.bentobox.limits; -import org.bukkit.plugin.java.annotation.dependency.Dependency; import org.bukkit.plugin.java.annotation.plugin.ApiVersion; import org.bukkit.plugin.java.annotation.plugin.Plugin; @@ -12,9 +11,8 @@ import world.bentobox.bentobox.api.addons.Pladdon; * @author YellowZaki */ -@Plugin(name="Pladdon", version="1.0") +@Plugin(name="Limits", version="1.0") @ApiVersion(ApiVersion.Target.v1_16) -@Dependency(value = "BentoBox") public class LimitsPladdon extends Pladdon { @Override From e17245b86f16938173ebcc3dea80f017a86d5599 Mon Sep 17 00:00:00 2001 From: BONNe Date: Sat, 8 Apr 2023 19:16:00 +0300 Subject: [PATCH 23/28] Create plugin.yml --- src/main/resources/plugin.yml | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 src/main/resources/plugin.yml diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..6f9c056 --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,9 @@ +name: BentoBox-Limits +main: world.bentobox.limits.LimitsPladdon +version: ${project.version}${build.number} +api-version: "1.19" + +authors: [tastybento] +contributors: ["The BentoBoxWorld Community"] +website: https://bentobox.world +description: ${project.description} From 8dd35fabcf2ab3bbae3ba20b53d954458664ae62 Mon Sep 17 00:00:00 2001 From: BONNe Date: Sat, 8 Apr 2023 19:16:35 +0300 Subject: [PATCH 24/28] Update pom.xml --- pom.xml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/pom.xml b/pom.xml index 94ef9fc..a35d5b3 100644 --- a/pom.xml +++ b/pom.xml @@ -135,12 +135,6 @@ ${spigot.version} provided - - org.spigotmc - plugin-annotations - 1.2.3-SNAPSHOT - provided - org.mockito From d87d194c65bb324ccfcac06f7ced629e6e86b164 Mon Sep 17 00:00:00 2001 From: BONNe Date: Sat, 8 Apr 2023 19:16:52 +0300 Subject: [PATCH 25/28] Update LimitsPladdon.java --- src/main/java/world/bentobox/limits/LimitsPladdon.java | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/main/java/world/bentobox/limits/LimitsPladdon.java b/src/main/java/world/bentobox/limits/LimitsPladdon.java index 3a1eac0..d1265de 100644 --- a/src/main/java/world/bentobox/limits/LimitsPladdon.java +++ b/src/main/java/world/bentobox/limits/LimitsPladdon.java @@ -1,18 +1,10 @@ package world.bentobox.limits; -import org.bukkit.plugin.java.annotation.plugin.ApiVersion; -import org.bukkit.plugin.java.annotation.plugin.Plugin; import world.bentobox.bentobox.api.addons.Addon; import world.bentobox.bentobox.api.addons.Pladdon; -/** - * - * @author YellowZaki - */ -@Plugin(name="Limits", version="1.0") -@ApiVersion(ApiVersion.Target.v1_16) public class LimitsPladdon extends Pladdon { @Override From eeafa239c4b5cb1b03f8890d9ab5ba03d8818a10 Mon Sep 17 00:00:00 2001 From: tastybento Date: Sat, 15 Apr 2023 11:44:56 -0700 Subject: [PATCH 26/28] Avoid using NumberUtils. Update dependencies. --- pom.xml | 4 ++-- .../world/bentobox/limits/listeners/JoinListener.java | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/pom.xml b/pom.xml index a35d5b3..7986b95 100644 --- a/pom.xml +++ b/pom.xml @@ -57,8 +57,8 @@ 2.0.9 - 1.16.5-R0.1-SNAPSHOT - 1.18.0-SNAPSHOT + 1.19.4-R0.1-SNAPSHOT + 1.23.0-SNAPSHOT ${build.version}-SNAPSHOT diff --git a/src/main/java/world/bentobox/limits/listeners/JoinListener.java b/src/main/java/world/bentobox/limits/listeners/JoinListener.java index 1e0830e..388e52e 100644 --- a/src/main/java/world/bentobox/limits/listeners/JoinListener.java +++ b/src/main/java/world/bentobox/limits/listeners/JoinListener.java @@ -5,7 +5,6 @@ import java.util.Locale; import java.util.Objects; import java.util.UUID; -import org.apache.commons.lang.math.NumberUtils; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.OfflinePlayer; @@ -118,11 +117,12 @@ public class JoinListener implements Listener { return true; } // Check value - if (!NumberUtils.isDigits(split[4])) { - logError(name, perms.getPermission(), "the last part MUST be a number!"); + try { + Integer.parseInt(split[4]); + } catch(Exception e) { + logError(name, perms.getPermission(), "the last part MUST be an integer!"); return true; } - return false; } From 6b770d083e22fb35a1eac0bc584976894b884a05 Mon Sep 17 00:00:00 2001 From: tastybento Date: Sat, 15 Apr 2023 12:15:14 -0700 Subject: [PATCH 27/28] Fix tests. Use world#nearbyEntities method. --- pom.xml | 41 +++++++++++++------ .../limits/listeners/EntityLimitListener.java | 10 ++--- .../limits/listeners/JoinListenerTest.java | 2 +- .../listeners/EntityLimitListenerTest.java | 7 +--- 4 files changed, 34 insertions(+), 26 deletions(-) diff --git a/pom.xml b/pom.xml index 7986b95..4ebfc30 100644 --- a/pom.xml +++ b/pom.xml @@ -53,12 +53,12 @@ UTF-8 UTF-8 - 16 + 17 2.0.9 1.19.4-R0.1-SNAPSHOT - 1.23.0-SNAPSHOT + 1.23.0 ${build.version}-SNAPSHOT @@ -196,7 +196,7 @@ maven-resources-plugin 3.1.0 - + org.apache.maven.plugins maven-surefire-plugin 3.0.0-M5 @@ -207,19 +207,29 @@ --add-opens java.base/java.math=ALL-UNNAMED --add-opens java.base/java.io=ALL-UNNAMED --add-opens java.base/java.util=ALL-UNNAMED - --add-opens java.base/java.util.stream=ALL-UNNAMED + --add-opens + java.base/java.util.stream=ALL-UNNAMED --add-opens java.base/java.text=ALL-UNNAMED - --add-opens java.base/java.util.regex=ALL-UNNAMED - --add-opens java.base/java.nio.channels.spi=ALL-UNNAMED + --add-opens + java.base/java.util.regex=ALL-UNNAMED + --add-opens + java.base/java.nio.channels.spi=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED --add-opens java.base/java.net=ALL-UNNAMED - --add-opens java.base/java.util.concurrent=ALL-UNNAMED + --add-opens + java.base/java.util.concurrent=ALL-UNNAMED --add-opens java.base/sun.nio.fs=ALL-UNNAMED --add-opens java.base/sun.nio.cs=ALL-UNNAMED --add-opens java.base/java.nio.file=ALL-UNNAMED - --add-opens java.base/java.nio.charset=ALL-UNNAMED - --add-opens java.base/java.lang.reflect=ALL-UNNAMED - --add-opens java.logging/java.util.logging=ALL-UNNAMED + --add-opens + java.base/java.nio.charset=ALL-UNNAMED + --add-opens + java.base/java.lang.reflect=ALL-UNNAMED + --add-opens + java.logging/java.util.logging=ALL-UNNAMED + --add-opens java.base/java.lang.ref=ALL-UNNAMED + --add-opens java.base/java.util.jar=ALL-UNNAMED + --add-opens java.base/java.util.zip=ALL-UNNAMED @@ -241,7 +251,7 @@ org.jacoco jacoco-maven-plugin - 0.8.3 + 0.8.7 true @@ -252,16 +262,21 @@ - pre-unit-test + prepare-agent prepare-agent - post-unit-test + report report + + + XML + + diff --git a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java index 9bf49aa..3f3cf3e 100644 --- a/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java +++ b/src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java @@ -403,10 +403,6 @@ public class EntityLimitListener implements Listener { // We have to count the entities if (limitAmount >= 0) { -// int count = (int) ent.getWorld().getEntities().stream() -// .filter(e -> e.getType().equals(ent.getType())) -// .filter(e -> island.inIslandSpace(e.getLocation())) -// .count(); int count = (int) ent.getWorld().getNearbyEntities(island.getBoundingBox()).stream() .filter(e -> e.getType().equals(ent.getType())) .count(); @@ -427,9 +423,9 @@ public class EntityLimitListener implements Listener { for (Map.Entry group : groupsLimits.entrySet()) { //do not use lambda if (group.getValue() < 0) continue; -// int count = (int) ent.getWorld().getEntities().stream() -// .filter(e -> group.getKey().contains(e.getType())) -// .filter(e -> island.inIslandSpace(e.getLocation())).count(); + // int count = (int) ent.getWorld().getEntities().stream() + // .filter(e -> group.getKey().contains(e.getType())) + // .filter(e -> island.inIslandSpace(e.getLocation())).count(); int count = (int) ent.getWorld().getNearbyEntities(island.getBoundingBox()).stream() .filter(e -> group.getKey().contains(e.getType())) .count(); diff --git a/src/test/java/bentobox/addon/limits/listeners/JoinListenerTest.java b/src/test/java/bentobox/addon/limits/listeners/JoinListenerTest.java index c0ca01a..eccda2f 100644 --- a/src/test/java/bentobox/addon/limits/listeners/JoinListenerTest.java +++ b/src/test/java/bentobox/addon/limits/listeners/JoinListenerTest.java @@ -298,7 +298,7 @@ public class JoinListenerTest { when(player.getEffectivePermissions()).thenReturn(perms); PlayerJoinEvent e = new PlayerJoinEvent(player, "welcome"); jl.onPlayerJoin(e); - verify(addon).logError("Player tastybento has permission: 'bskyblock.island.limit.STONE.abc' but the last part MUST be a number! Ignoring..."); + verify(addon).logError("Player tastybento has permission: 'bskyblock.island.limit.STONE.abc' but the last part MUST be an integer! Ignoring..."); } /** diff --git a/src/test/java/world/bentobox/limits/listeners/EntityLimitListenerTest.java b/src/test/java/world/bentobox/limits/listeners/EntityLimitListenerTest.java index a5e6da4..2e3c3c2 100644 --- a/src/test/java/world/bentobox/limits/listeners/EntityLimitListenerTest.java +++ b/src/test/java/world/bentobox/limits/listeners/EntityLimitListenerTest.java @@ -19,6 +19,7 @@ import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.Entity; import org.bukkit.entity.EntityType; import org.bukkit.entity.LivingEntity; +import org.bukkit.util.BoundingBox; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -80,15 +81,11 @@ public class EntityLimitListenerTest { collection.add(ent); collection.add(ent); collection.add(ent); - when(world.getEntities()).thenReturn(collection); + when(world.getNearbyEntities(any())).thenReturn(collection); ell = new EntityLimitListener(addon); } - @After - public void tearDown() { - } - /** * Test for {@link EntityLimitListener#atLimit(Island, Entity)} */ From e16d1f18930eee912157dc9e4bbae6560bfade0b Mon Sep 17 00:00:00 2001 From: tastybento Date: Sat, 15 Apr 2023 15:44:18 -0700 Subject: [PATCH 28/28] Java 17 for GitHub action --- .github/workflows/build.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index b9cf60c..c771fd5 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -14,10 +14,10 @@ jobs: - uses: actions/checkout@v2 with: fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis - - name: Set up JDK 16 + - name: Set up JDK 17 uses: actions/setup-java@v1 with: - java-version: 16 + java-version: 17 - name: Cache SonarCloud packages uses: actions/cache@v1 with: