From c0c9e16b6cc0a40c8b5db92d520573082bab327e Mon Sep 17 00:00:00 2001 From: tastybento Date: Sat, 14 Nov 2020 11:03:13 -0800 Subject: [PATCH] Added new event that fires for each perm https://github.com/BentoBoxWorld/Limits/issues/111 --- .../java/world/bentobox/limits/Settings.java | 4 + .../limits/events/LimitsPermCheckEvent.java | 194 ++++++++++++++++++ .../limits/listeners/JoinListener.java | 24 ++- 3 files changed, 217 insertions(+), 5 deletions(-) create mode 100644 src/main/java/world/bentobox/limits/events/LimitsPermCheckEvent.java diff --git a/src/main/java/world/bentobox/limits/Settings.java b/src/main/java/world/bentobox/limits/Settings.java index 8782699..f53cce9 100644 --- a/src/main/java/world/bentobox/limits/Settings.java +++ b/src/main/java/world/bentobox/limits/Settings.java @@ -133,6 +133,10 @@ public class Settings { return gameModes; } + /** + * A named class representing a group of entities and their limits + * + */ public static class EntityGroup { private final String name; private final Set types; diff --git a/src/main/java/world/bentobox/limits/events/LimitsPermCheckEvent.java b/src/main/java/world/bentobox/limits/events/LimitsPermCheckEvent.java new file mode 100644 index 0000000..7afa448 --- /dev/null +++ b/src/main/java/world/bentobox/limits/events/LimitsPermCheckEvent.java @@ -0,0 +1,194 @@ +package world.bentobox.limits.events; + +import org.bukkit.Material; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.Player; +import org.bukkit.event.Cancellable; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; + +import world.bentobox.bentobox.api.events.BentoBoxEvent; +import world.bentobox.limits.Settings.EntityGroup; +import world.bentobox.limits.objects.IslandBlockCount; + +/** + * Fired when a player joins the server and before limit settings for their island are changed based + * on the player's permissions. If cancelled, no limit settings will be made. + * @author tastybento + * + */ +public class LimitsPermCheckEvent extends BentoBoxEvent implements Cancellable { + + private final Player player; + private final String islandId; + private IslandBlockCount ibc; + private boolean ignorePerms; + private boolean cancel; + private @Nullable EntityGroup entityGroup; + private @Nullable EntityType entityType; + private @Nullable Material material; + private int value; + + /** + * Fired when a player joins the server and before limit settings for their island are changed based + * on the player's permissions. If cancelled, no limit settings will be made. + * @param player - player joining + * @param islandId - the unique island id. + * @param ibc - IslandBlockCount object for this island + * @param material - material being limited, or null + * @param entityType - entity type being limited, or null + * @param entgroup - entity group being limited, or null + * @param value - numeric limit given by the perm + */ + public LimitsPermCheckEvent(@NonNull Player player, + @NonNull String islandId, + @Nullable IslandBlockCount ibc, + @Nullable EntityGroup entgroup, + @Nullable EntityType entityType, + @Nullable Material material, + int value) { + super(); + this.player = player; + this.islandId = islandId; + this.ibc = ibc; + this.entityGroup = entgroup; + this.entityType = entityType; + this.material = material; + this.value = value; + } + + + /** + * Get the player joining + * @return the player + */ + @NonNull + public Player getPlayer() { + return player; + } + + + /** + * Get the unique island id. Use the islands manager to obtain the island + * @return the islandId + */ + @NonNull + public String getIslandId() { + return islandId; + } + + + /** + * Get the island block count + * @return the ibc + */ + @Nullable + public IslandBlockCount getIbc() { + return ibc; + } + + + /** + * Set the island block count to a specific setting + * @param ibc the ibc to set + */ + public void setIbc(@Nullable IslandBlockCount ibc) { + this.ibc = ibc; + } + + + @Override + public boolean isCancelled() { + return this.cancel; + } + + @Override + public void setCancelled(boolean cancel) { + this.cancel = cancel; + + } + + + /** + * Check if player's perms should be considered or not + * @return the ignorePerms + */ + public boolean isIgnorePerms() { + return ignorePerms; + } + + + /** + * Ignore player's perms. This differs to canceling the event in that the IslandBlockCount will be used if given via + * {@link setIbc(IslandBlockCount ibc)} + * @param ignorePerms the ignorePerms to set + */ + public void setIgnorePerms(boolean ignorePerms) { + this.ignorePerms = ignorePerms; + } + + /** + * @return the entityGroup + */ + public EntityGroup getEntityGroup() { + return entityGroup; + } + + + /** + * @param entityGroup the entityGroup to set + */ + public void setEntityGroup(EntityGroup entityGroup) { + this.entityGroup = entityGroup; + } + + + /** + * @return the entityType + */ + public EntityType getEntityType() { + return entityType; + } + + + /** + * @param entityType the entityType to set + */ + public void setEntityType(EntityType entityType) { + this.entityType = entityType; + } + + + /** + * @return the material + */ + public Material getMaterial() { + return material; + } + + + /** + * @param material the material to set + */ + public void setMaterial(Material material) { + this.material = material; + } + + + /** + * @return the value + */ + public int getValue() { + return value; + } + + + /** + * @param value the value to set + */ + public void setValue(int value) { + this.value = value; + } + + +} diff --git a/src/main/java/world/bentobox/limits/listeners/JoinListener.java b/src/main/java/world/bentobox/limits/listeners/JoinListener.java index e3cddef..e0c0c17 100644 --- a/src/main/java/world/bentobox/limits/listeners/JoinListener.java +++ b/src/main/java/world/bentobox/limits/listeners/JoinListener.java @@ -25,6 +25,7 @@ import world.bentobox.bentobox.database.objects.Island; import world.bentobox.limits.Limits; import world.bentobox.limits.Settings.EntityGroup; import world.bentobox.limits.events.LimitsJoinPermCheckEvent; +import world.bentobox.limits.events.LimitsPermCheckEvent; import world.bentobox.limits.objects.IslandBlockCount; /** @@ -91,22 +92,35 @@ public class JoinListener implements Listener { if (ibc == null) { ibc = new IslandBlockCount(islandId, gameMode); } + + int value = Integer.valueOf(split[4]); + // Fire perm check event + LimitsPermCheckEvent l = new LimitsPermCheckEvent(player, gameMode, ibc, entgroup, et, m, value); + Bukkit.getPluginManager().callEvent(l); + if (l.isCancelled()) continue; + // Use event values + ibc = l.getIbc(); + entgroup = l.getEntityGroup(); + et = l.getEntityType(); + m = l.getMaterial(); + value = l.getValue(); + if (entgroup != null) { // Entity group limit - ibc.setEntityGroupLimit(entgroup.getName(), Math.max(ibc.getEntityGroupLimit(entgroup.getName()), Integer.valueOf(split[4]))); + ibc.setEntityGroupLimit(entgroup.getName(), Math.max(ibc.getEntityGroupLimit(entgroup.getName()), value)); } else if (et != null && m == null) { // Entity limit - ibc.setEntityLimit(et, Math.max(ibc.getEntityLimit(et), Integer.valueOf(split[4]))); + ibc.setEntityLimit(et, Math.max(ibc.getEntityLimit(et), value)); } else if (m != null && et == null) { // Material limit - ibc.setBlockLimit(m, Math.max(ibc.getBlockLimit(m), Integer.valueOf(split[4]))); + ibc.setBlockLimit(m, Math.max(ibc.getBlockLimit(m), value)); } else { if (m.isBlock()) { // Material limit - ibc.setBlockLimit(m, Math.max(ibc.getBlockLimit(m), Integer.valueOf(split[4]))); + ibc.setBlockLimit(m, Math.max(ibc.getBlockLimit(m), value)); } else { // This is an entity setting - ibc.setEntityLimit(et, Math.max(ibc.getEntityLimit(et), Integer.valueOf(split[4]))); + ibc.setEntityLimit(et, Math.max(ibc.getEntityLimit(et), value)); } } }