From bb11a7aec9cc7b23f820b1fa548aa7f316d64c66 Mon Sep 17 00:00:00 2001 From: dordsor21 Date: Sun, 24 Aug 2025 17:00:39 +0100 Subject: [PATCH] feat: implement better add/trust/deny/remove events - closes #3509 --- .../com/plotsquared/core/command/Add.java | 47 +++++++--- .../com/plotsquared/core/command/Deny.java | 18 +++- .../com/plotsquared/core/command/Leave.java | 13 +++ .../com/plotsquared/core/command/Remove.java | 17 ++++ .../com/plotsquared/core/command/Trust.java | 50 ++++++++--- .../core/events/PlayerPlotAddEvent.java | 45 ++++++++++ .../PlayerPlotAddRemoveCancellableEvent.java | 55 ++++++++++++ .../core/events/PlayerPlotAddRemoveEvent.java | 88 +++++++++++++++++++ .../core/events/PlayerPlotDeniedEvent.java | 12 +++ .../core/events/PlayerPlotDenyEvent.java | 45 ++++++++++ .../core/events/PlayerPlotHelperEvent.java | 11 ++- .../core/events/PlayerPlotRemoveEvent.java | 45 ++++++++++ .../core/events/PlayerPlotTrustEvent.java | 45 ++++++++++ .../core/events/PlayerPlotTrustedEvent.java | 12 +++ .../post/PostPlayerPlotAddRemoveEvent.java | 56 ++++++++++++ .../events/post/PostPlayerPlotAddedEvent.java | 46 ++++++++++ .../post/PostPlayerPlotDeniedEvent.java | 46 ++++++++++ .../post/PostPlayerPlotTrustedEvent.java | 46 ++++++++++ .../java/com/plotsquared/core/plot/Plot.java | 52 +++++++++-- .../com/plotsquared/core/plot/PlotArea.java | 48 +++++++++- .../core/util/EventDispatcher.java | 67 ++++++++++++++ 21 files changed, 824 insertions(+), 40 deletions(-) create mode 100644 Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveCancellableEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/PlayerPlotDenyEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/PlayerPlotRemoveEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddRemoveEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddedEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotDeniedEvent.java create mode 100644 Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotTrustedEvent.java diff --git a/Core/src/main/java/com/plotsquared/core/command/Add.java b/Core/src/main/java/com/plotsquared/core/command/Add.java index 02a7124d2..940fa7a36 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Add.java +++ b/Core/src/main/java/com/plotsquared/core/command/Add.java @@ -23,6 +23,8 @@ import com.plotsquared.core.PlotSquared; import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.configuration.caption.TranslatableCaption; import com.plotsquared.core.database.DBFunc; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; +import com.plotsquared.core.events.Result; import com.plotsquared.core.permissions.Permission; import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.plot.Plot; @@ -151,20 +153,41 @@ public class Add extends Command { return; } // Success - confirm.run(this, () -> { - for (UUID uuid : uuids) { - if (uuid != DBFunc.EVERYONE) { - if (!plot.removeTrusted(uuid)) { - if (plot.getDenied().contains(uuid)) { - plot.removeDenied(uuid); + confirm.run( + this, () -> { + for (UUID uuid : uuids) { + if (this.eventDispatcher.callPlayerAdd( + player, + plot, + uuid, + PlayerPlotAddRemoveEvent.Reason.COMMAND + ).getEventResult() == Result.DENY) { + player.sendMessage( + TranslatableCaption.of("events.event_denied"), + TagResolver.resolver("value", Tag.inserting(Component.text("Add"))) + ); + continue; } + if (uuid != DBFunc.EVERYONE) { + if (!plot.removeTrusted(uuid)) { + if (plot.getDenied().contains(uuid)) { + plot.removeDenied(uuid); + } + } + } + plot.addMember(uuid); + this.eventDispatcher.callMember(player, plot, uuid, true); + this.eventDispatcher.callPostAdded( + player, + plot, + uuid, + false, + PlayerPlotAddRemoveEvent.Reason.COMMAND + ); + player.sendMessage(TranslatableCaption.of("member.member_added")); } - } - plot.addMember(uuid); - this.eventDispatcher.callMember(player, plot, uuid, true); - player.sendMessage(TranslatableCaption.of("member.member_added")); - } - }, null); + }, null + ); } catch (final Throwable exception) { future.completeExceptionally(exception); return; diff --git a/Core/src/main/java/com/plotsquared/core/command/Deny.java b/Core/src/main/java/com/plotsquared/core/command/Deny.java index 56e7c2c8a..4e4bf74d2 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Deny.java +++ b/Core/src/main/java/com/plotsquared/core/command/Deny.java @@ -23,6 +23,8 @@ import com.plotsquared.core.PlotSquared; import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.configuration.caption.TranslatableCaption; import com.plotsquared.core.database.DBFunc; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; +import com.plotsquared.core.events.Result; import com.plotsquared.core.events.TeleportCause; import com.plotsquared.core.location.Location; import com.plotsquared.core.permissions.Permission; @@ -125,21 +127,29 @@ public class Deny extends SubCommand { ); return; } else { + if (this.eventDispatcher + .callPlayerDeny(player, plot, uuid, PlayerPlotAddRemoveEvent.Reason.COMMAND) + .getEventResult() == Result.DENY) { + player.sendMessage( + TranslatableCaption.of("events.event_denied"), + TagResolver.resolver("value", Tag.inserting(Component.text("Deny"))) + ); + continue; + } if (uuid != DBFunc.EVERYONE) { plot.removeMember(uuid); plot.removeTrusted(uuid); } plot.addDenied(uuid); this.eventDispatcher.callDenied(player, plot, uuid, true); + this.eventDispatcher.callPostDenied(player, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.COMMAND); if (!uuid.equals(DBFunc.EVERYONE)) { handleKick(PlotSquared.platform().playerManager().getPlayerIfExists(uuid), plot); } else { for (PlotPlayer plotPlayer : plot.getPlayersInPlot()) { - // Ignore plot-owners - if (plot.isAdded(plotPlayer.getUUID())) { - continue; + if (plot.isDenied(plotPlayer.getUUID())) { + handleKick(plotPlayer, plot); } - handleKick(plotPlayer, plot); } } } diff --git a/Core/src/main/java/com/plotsquared/core/command/Leave.java b/Core/src/main/java/com/plotsquared/core/command/Leave.java index bb81c3342..ab59b7fe4 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Leave.java +++ b/Core/src/main/java/com/plotsquared/core/command/Leave.java @@ -20,6 +20,8 @@ package com.plotsquared.core.command; import com.google.inject.Inject; import com.plotsquared.core.configuration.caption.TranslatableCaption; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; +import com.plotsquared.core.events.Result; import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.plot.Plot; import com.plotsquared.core.util.EventDispatcher; @@ -61,11 +63,22 @@ public class Leave extends Command { } else { UUID uuid = player.getUUID(); if (plot.isAdded(uuid)) { + if (this.eventDispatcher + .callPlayerRemove(player, plot, uuid, PlayerPlotAddRemoveEvent.Reason.COMMAND) + .getEventResult() == Result.DENY) { + player.sendMessage( + TranslatableCaption.of("events.event_denied"), + TagResolver.resolver("value", Tag.inserting(Component.text("Leave"))) + ); + return CompletableFuture.completedFuture(true); + } if (plot.removeTrusted(uuid)) { this.eventDispatcher.callTrusted(player, plot, uuid, false); + this.eventDispatcher.callPostTrusted(player, plot, uuid, false, PlayerPlotAddRemoveEvent.Reason.COMMAND); } if (plot.removeMember(uuid)) { this.eventDispatcher.callMember(player, plot, uuid, false); + this.eventDispatcher.callPostAdded(player, plot, uuid, false, PlayerPlotAddRemoveEvent.Reason.COMMAND); } player.sendMessage( TranslatableCaption.of("member.plot_left"), diff --git a/Core/src/main/java/com/plotsquared/core/command/Remove.java b/Core/src/main/java/com/plotsquared/core/command/Remove.java index 287145df5..b298e5abd 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Remove.java +++ b/Core/src/main/java/com/plotsquared/core/command/Remove.java @@ -21,6 +21,8 @@ package com.plotsquared.core.command; import com.google.inject.Inject; import com.plotsquared.core.configuration.caption.TranslatableCaption; import com.plotsquared.core.database.DBFunc; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; +import com.plotsquared.core.events.Result; import com.plotsquared.core.location.Location; import com.plotsquared.core.permissions.Permission; import com.plotsquared.core.player.PlotPlayer; @@ -84,33 +86,48 @@ public class Remove extends SubCommand { return; } else if (!uuids.isEmpty()) { for (UUID uuid : uuids) { + if (this.eventDispatcher + .callPlayerRemove(player, plot, uuid, PlayerPlotAddRemoveEvent.Reason.COMMAND) + .getEventResult() == Result.DENY) { + player.sendMessage( + TranslatableCaption.of("events.event_denied"), + TagResolver.resolver("value", Tag.inserting(Component.text("Remove"))) + ); + continue; + } if (plot.getTrusted().contains(uuid)) { if (plot.removeTrusted(uuid)) { this.eventDispatcher.callTrusted(player, plot, uuid, false); + this.eventDispatcher.callPostTrusted(player, plot, uuid, false, PlayerPlotAddRemoveEvent.Reason.COMMAND); count++; } } else if (plot.getMembers().contains(uuid)) { if (plot.removeMember(uuid)) { this.eventDispatcher.callMember(player, plot, uuid, false); + this.eventDispatcher.callPostAdded(player, plot, uuid, false, PlayerPlotAddRemoveEvent.Reason.COMMAND); count++; } } else if (plot.getDenied().contains(uuid)) { if (plot.removeDenied(uuid)) { this.eventDispatcher.callDenied(player, plot, uuid, false); + this.eventDispatcher.callPostDenied(player, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.COMMAND); count++; } } else if (uuid == DBFunc.EVERYONE) { count += plot.getTrusted().size(); if (plot.removeTrusted(uuid)) { this.eventDispatcher.callTrusted(player, plot, uuid, false); + this.eventDispatcher.callPostTrusted(player, plot, uuid, false, PlayerPlotAddRemoveEvent.Reason.COMMAND); } count += plot.getMembers().size(); if (plot.removeMember(uuid)) { this.eventDispatcher.callMember(player, plot, uuid, false); + this.eventDispatcher.callPostAdded(player, plot, uuid, false, PlayerPlotAddRemoveEvent.Reason.COMMAND); } count += plot.getDenied().size(); if (plot.removeDenied(uuid)) { this.eventDispatcher.callDenied(player, plot, uuid, false); + this.eventDispatcher.callPostDenied(player, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.COMMAND); } } } diff --git a/Core/src/main/java/com/plotsquared/core/command/Trust.java b/Core/src/main/java/com/plotsquared/core/command/Trust.java index 23d306ad3..7f2c1d478 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Trust.java +++ b/Core/src/main/java/com/plotsquared/core/command/Trust.java @@ -23,6 +23,8 @@ import com.plotsquared.core.PlotSquared; import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.configuration.caption.TranslatableCaption; import com.plotsquared.core.database.DBFunc; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; +import com.plotsquared.core.events.Result; import com.plotsquared.core.permissions.Permission; import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.plot.Plot; @@ -150,23 +152,43 @@ public class Trust extends Command { return; } // Success - confirm.run(this, () -> { - for (UUID uuid : uuids) { - if (uuid != DBFunc.EVERYONE) { - if (!currentPlot.removeMember(uuid)) { - if (currentPlot.getDenied().contains(uuid)) { - currentPlot.removeDenied(uuid); + confirm.run( + this, () -> { + for (UUID uuid : uuids) { + if (this.eventDispatcher + .callPlayerTrust(player, currentPlot, uuid, PlayerPlotAddRemoveEvent.Reason.COMMAND) + .getEventResult() == Result.DENY) { + player.sendMessage( + TranslatableCaption.of("events.event_denied"), + TagResolver.resolver("value", Tag.inserting(Component.text("Trust"))) + ); + return; } + + if (uuid != DBFunc.EVERYONE) { + if (!currentPlot.removeMember(uuid)) { + if (currentPlot.getDenied().contains(uuid)) { + currentPlot.removeDenied(uuid); + } + } + } + currentPlot.addTrusted(uuid); + this.eventDispatcher.callTrusted(player, currentPlot, uuid, true); + this.eventDispatcher.callPostTrusted( + player, + currentPlot, + uuid, + false, + PlayerPlotAddRemoveEvent.Reason.COMMAND + ); + player.sendMessage(TranslatableCaption.of("trusted.trusted_added")); } - } - currentPlot.addTrusted(uuid); - this.eventDispatcher.callTrusted(player, currentPlot, uuid, true); - player.sendMessage(TranslatableCaption.of("trusted.trusted_added")); - } - }, null); + }, null + ); } - future.complete(true); - }); + future.complete(true); + } + ); return CompletableFuture.completedFuture(true); } diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddEvent.java new file mode 100644 index 000000000..ae9b63f51 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddEvent.java @@ -0,0 +1,45 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Called when a player is going to be added to a plot + * + * @since TODO + */ +public class PlayerPlotAddEvent extends PlayerPlotAddRemoveCancellableEvent { + + /** + * Called when a player will be added to a plot + * + * @param initiator Player that initiated the event + * @param plot Plot in which the event occurred + * @param player Player that will be added + * @param reason The reason for the add + */ + public PlayerPlotAddEvent(PlotPlayer initiator, Plot plot, UUID player, Reason reason) { + super(initiator, plot, player, reason); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveCancellableEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveCancellableEvent.java new file mode 100644 index 000000000..2b862284b --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveCancellableEvent.java @@ -0,0 +1,55 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; +import org.checkerframework.checker.nullness.qual.Nullable; + +import java.util.UUID; + +/** + * Parent class for the varies events regarding a player being added/removed/denied/trusted + * + * @since TODO + */ +public class PlayerPlotAddRemoveCancellableEvent extends PlayerPlotAddRemoveEvent implements CancellablePlotEvent { + + private Result eventResult; + + protected PlayerPlotAddRemoveCancellableEvent( + final PlotPlayer initiator, + Plot plot, + final UUID player, + final Reason reason + ) { + super(initiator, plot, player, reason); + } + + @Override + public @Nullable Result getEventResult() { + return eventResult; + } + + @Override + public void setEventResult(@Nullable final Result eventResult) { + this.eventResult = eventResult; + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveEvent.java new file mode 100644 index 000000000..f78adadf8 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotAddRemoveEvent.java @@ -0,0 +1,88 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; +import org.checkerframework.checker.nullness.qual.Nullable; + +import java.util.UUID; + +/** + * Parent class for the varies events regarding a player being added/removed/denied/trusted + * + * @since TODO + */ +public class PlayerPlotAddRemoveEvent extends PlotEvent { + + private final Reason reason; + private final PlotPlayer initiator; + private final UUID player; + + protected PlayerPlotAddRemoveEvent(final PlotPlayer initiator, Plot plot, final UUID player, final Reason reason) { + super(plot); + this.initiator = initiator; + this.player = player; + this.reason = reason; + } + + /** + * The player to be added/denied/removed/trusted. + * + * @return UUID + */ + public UUID getPlayer() { + return this.player; + } + + /** + * The player initiating the action. May be null (if a player, or a {@link com.plotsquared.core.player.ConsolePlayer}. + * + * @return PlotPlayer + */ + @Nullable + public PlotPlayer getInitiator() { + return this.initiator; + } + + /** + * Get the reason the player is being added/removed/denied/trusted + * + * @return Reason + */ + public Reason getReason() { + return this.reason; + } + + public enum Reason { + /** + * If a plot merge caused the player to be added/removed/denied/trusted + */ + MERGE, + /** + * If a command caused the player to be added/removed/denied/trusted + */ + COMMAND, + /** + * If something unknown caused the player to be added/removed/denied/trusted + */ + UNKNOWN + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotDeniedEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotDeniedEvent.java index 52bb24a9f..9eb166d91 100644 --- a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotDeniedEvent.java +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotDeniedEvent.java @@ -23,6 +23,10 @@ import com.plotsquared.core.plot.Plot; import java.util.UUID; +/** + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotDeniedEvent} + */ +@Deprecated(forRemoval = true, since = "TODO") public class PlayerPlotDeniedEvent extends PlotEvent { private final PlotPlayer initiator; @@ -36,7 +40,9 @@ public class PlayerPlotDeniedEvent extends PlotEvent { * @param plot Plot in which the event occurred * @param player Player that was denied/un-denied * @param added {@code true} of add to deny list, {@code false} if removed + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotDeniedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public PlayerPlotDeniedEvent(PlotPlayer initiator, Plot plot, UUID player, boolean added) { super(plot); this.initiator = initiator; @@ -48,7 +54,9 @@ public class PlayerPlotDeniedEvent extends PlotEvent { * If a user was added. * * @return boolean + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotDeniedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public boolean wasAdded() { return this.added; } @@ -57,7 +65,9 @@ public class PlayerPlotDeniedEvent extends PlotEvent { * The player added/removed. * * @return UUID + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotDeniedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public UUID getPlayer() { return this.player; } @@ -66,7 +76,9 @@ public class PlayerPlotDeniedEvent extends PlotEvent { * The player initiating the action. * * @return PlotPlayer + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotDeniedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public PlotPlayer getInitiator() { return this.initiator; } diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotDenyEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotDenyEvent.java new file mode 100644 index 000000000..a7ad0fe50 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotDenyEvent.java @@ -0,0 +1,45 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Called when a player is going to be denied from a plot + * + * @since TODO + */ +public class PlayerPlotDenyEvent extends PlayerPlotAddRemoveCancellableEvent { + + /** + * Called when a player will be denied from a plot + * + * @param initiator Player that initiated the event + * @param plot Plot in which the event occurred + * @param player Player that will be denied + * @param reason The reason for the deny + */ + public PlayerPlotDenyEvent(PlotPlayer initiator, Plot plot, UUID player, Reason reason) { + super(initiator, plot, player, reason); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotHelperEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotHelperEvent.java index e262d1a4f..f46db2d74 100644 --- a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotHelperEvent.java +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotHelperEvent.java @@ -24,8 +24,9 @@ import com.plotsquared.core.plot.Plot; import java.util.UUID; /** - * + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotAddedEvent} */ +@Deprecated(forRemoval = true, since = "TODO") public class PlayerPlotHelperEvent extends PlotEvent { private final PlotPlayer initiator; @@ -39,7 +40,9 @@ public class PlayerPlotHelperEvent extends PlotEvent { * @param plot Plot in which the event occurred * @param player Player that was added/removed from the helper list * @param added {@code true} if the player was added, {@code false} if the player was removed + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotAddedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public PlayerPlotHelperEvent(PlotPlayer initiator, Plot plot, UUID player, boolean added) { super(plot); this.initiator = initiator; @@ -51,7 +54,9 @@ public class PlayerPlotHelperEvent extends PlotEvent { * If a player was added * * @return boolean + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotAddedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public boolean wasAdded() { return this.added; } @@ -60,7 +65,9 @@ public class PlayerPlotHelperEvent extends PlotEvent { * The UUID added/removed * * @return UUID + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotAddedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public UUID getPlayer() { return this.player; } @@ -69,7 +76,9 @@ public class PlayerPlotHelperEvent extends PlotEvent { * The player initiating the action * * @return PlotPlayer + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotAddedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public PlotPlayer getInitiator() { return this.initiator; } diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotRemoveEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotRemoveEvent.java new file mode 100644 index 000000000..960c39990 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotRemoveEvent.java @@ -0,0 +1,45 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Called when a player is going to be removed from a plot (could be removed from added, trusted, or denied) + * + * @since TODO + */ +public class PlayerPlotRemoveEvent extends PlayerPlotAddRemoveCancellableEvent { + + /** + * Called when a player is going to be removed from a plot (could be removed from added, trusted, or denied) + * + * @param initiator Player that initiated the event + * @param plot Plot in which the event occurred + * @param player Player that will be removed + * @param reason The reason for the remove + */ + public PlayerPlotRemoveEvent(PlotPlayer initiator, Plot plot, UUID player, Reason reason) { + super(initiator, plot, player, reason); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustEvent.java new file mode 100644 index 000000000..0751a649d --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustEvent.java @@ -0,0 +1,45 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Called when a player is going to be trusted to a plot + * + * @since TODO + */ +public class PlayerPlotTrustEvent extends PlayerPlotAddRemoveCancellableEvent { + + /** + * Called when a player will be trusted to a plot + * + * @param initiator Player that initiated the event + * @param plot Plot in which the event occurred + * @param player Player that will be trusted + * @param reason The reason for the trust + */ + public PlayerPlotTrustEvent(PlotPlayer initiator, Plot plot, UUID player, Reason reason) { + super(initiator, plot, player, reason); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustedEvent.java b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustedEvent.java index cce45b9ab..70f029b62 100644 --- a/Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustedEvent.java +++ b/Core/src/main/java/com/plotsquared/core/events/PlayerPlotTrustedEvent.java @@ -23,6 +23,10 @@ import com.plotsquared.core.plot.Plot; import java.util.UUID; +/** + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotTrustedEvent} + */ +@Deprecated(forRemoval = true, since = "TODO") public class PlayerPlotTrustedEvent extends PlotEvent { private final PlotPlayer initiator; @@ -36,7 +40,9 @@ public class PlayerPlotTrustedEvent extends PlotEvent { * @param plot Plot in which the event occurred * @param player Player that was added/removed from the trusted list * @param added {@code true} if the player was added, {@code false} if the player was removed + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotTrustedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public PlayerPlotTrustedEvent(PlotPlayer initiator, Plot plot, UUID player, boolean added) { super(plot); this.initiator = initiator; @@ -48,7 +54,9 @@ public class PlayerPlotTrustedEvent extends PlotEvent { * If a player was added * * @return boolean + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotTrustedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public boolean wasAdded() { return this.added; } @@ -57,7 +65,9 @@ public class PlayerPlotTrustedEvent extends PlotEvent { * The UUID added/removed * * @return UUID + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotTrustedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public UUID getPlayer() { return this.player; } @@ -66,7 +76,9 @@ public class PlayerPlotTrustedEvent extends PlotEvent { * The player initiating the action * * @return PlotPlayer + * @deprecated Use {@link com.plotsquared.core.events.post.PostPlayerPlotTrustedEvent} */ + @Deprecated(forRemoval = true, since = "TODO") public PlotPlayer getInitiator() { return this.initiator; } diff --git a/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddRemoveEvent.java b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddRemoveEvent.java new file mode 100644 index 000000000..30d60dfee --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddRemoveEvent.java @@ -0,0 +1,56 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events.post; + +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Parent class for events covering players being added/removed to added/trusted/denied lists. + * + * @since TODO + */ +public sealed class PostPlayerPlotAddRemoveEvent extends PlayerPlotAddRemoveEvent permits PostPlayerPlotAddedEvent, + PostPlayerPlotDeniedEvent, PostPlayerPlotTrustedEvent { + + private final boolean added; + + protected PostPlayerPlotAddRemoveEvent( + final PlotPlayer initiator, + final Plot plot, + final UUID player, + final Reason reason, + boolean added + ) { + super(initiator, plot, player, reason); + this.added = added; + } + + /** + * Get if the player was added to a list, or removed. + */ + public boolean added() { + return added; + } + + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddedEvent.java b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddedEvent.java new file mode 100644 index 000000000..2d874bd27 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotAddedEvent.java @@ -0,0 +1,46 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events.post; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Called when a player is added to a plot + * + * @since TODO + */ +public final class PostPlayerPlotAddedEvent extends PostPlayerPlotAddRemoveEvent { + + /** + * PlayerPlotHelperEvent: Called when a player is added to a plot + * + * @param initiator Player that initiated the event + * @param plot Plot in which the event occurred + * @param player Player that was added/removed from the helper list + * @param added {@code true} if the player was added, {@code false} if the player was removed + * @param reason The reason for the add/remove + */ + public PostPlayerPlotAddedEvent(PlotPlayer initiator, Plot plot, UUID player, boolean added, Reason reason) { + super(initiator, plot, player, reason, added); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotDeniedEvent.java b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotDeniedEvent.java new file mode 100644 index 000000000..92f900b48 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotDeniedEvent.java @@ -0,0 +1,46 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events.post; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Called when a player is denied from a plot + * + * @since TODO + */ +public final class PostPlayerPlotDeniedEvent extends PostPlayerPlotAddRemoveEvent { + + /** + * PlayerPlotDeniedEvent: Called when the denied UUID list is modified for a plot. + * + * @param initiator Player that initiated the event + * @param plot Plot in which the event occurred + * @param player Player that was denied/un-denied + * @param added {@code true} of add to deny list, {@code false} if removed + * @param reason The reason for the deny/remove + */ + public PostPlayerPlotDeniedEvent(PlotPlayer initiator, Plot plot, UUID player, boolean added, Reason reason) { + super(initiator, plot, player, reason, added); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotTrustedEvent.java b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotTrustedEvent.java new file mode 100644 index 000000000..ae2731a08 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/events/post/PostPlayerPlotTrustedEvent.java @@ -0,0 +1,46 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.events.post; + +import com.plotsquared.core.player.PlotPlayer; +import com.plotsquared.core.plot.Plot; + +import java.util.UUID; + +/** + * Called when a plot trusted user is added/removed + * + * @since TODO + */ +public final class PostPlayerPlotTrustedEvent extends PostPlayerPlotAddRemoveEvent { + + /** + * PlayerPlotTrustedEvent: Called when a plot trusted user is added/removed + * + * @param initiator Player that initiated the event + * @param plot Plot in which the event occurred + * @param player Player that was added/removed from the trusted list + * @param added {@code true} if the player was added, {@code false} if the player was removed + * @param reason The reason for the trust/remove + */ + public PostPlayerPlotTrustedEvent(PlotPlayer initiator, Plot plot, UUID player, boolean added, Reason reason) { + super(initiator, plot, player, reason, added); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/plot/Plot.java b/Core/src/main/java/com/plotsquared/core/plot/Plot.java index 655dc6d3f..cc6e55516 100644 --- a/Core/src/main/java/com/plotsquared/core/plot/Plot.java +++ b/Core/src/main/java/com/plotsquared/core/plot/Plot.java @@ -29,6 +29,7 @@ import com.plotsquared.core.configuration.caption.CaptionUtility; import com.plotsquared.core.configuration.caption.StaticCaption; import com.plotsquared.core.configuration.caption.TranslatableCaption; import com.plotsquared.core.database.DBFunc; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; import com.plotsquared.core.events.PlayerTeleportToPlotEvent; import com.plotsquared.core.events.Result; import com.plotsquared.core.events.TeleportCause; @@ -974,7 +975,10 @@ public class Plot { * Sets the denied users for this plot. * * @param uuids uuids to deny + * @deprecated Use {@link Plot#addDenied(UUID)} (UUID)} calling + * {@link EventDispatcher#callPlayerDeny(PlotPlayer, Plot, UUID, PlayerPlotAddRemoveEvent.Reason)} for each. */ + @Deprecated public void setDenied(final @NonNull Set uuids) { boolean larger = uuids.size() > getDenied().size(); HashSet intersection; @@ -1015,7 +1019,10 @@ public class Plot { * Sets the trusted users for this plot. * * @param uuids uuids to trust + * @deprecated Use {@link Plot#addTrusted(UUID)} calling + * {@link EventDispatcher#callPlayerTrust(PlotPlayer, Plot, UUID, PlayerPlotAddRemoveEvent.Reason)} for each. */ + @Deprecated public void setTrusted(final @NonNull Set uuids) { boolean larger = uuids.size() > getTrusted().size(); HashSet intersection = new HashSet<>(larger ? getTrusted() : uuids); @@ -1047,7 +1054,10 @@ public class Plot { * Sets the members for this plot. * * @param uuids uuids to set member status for + * @deprecated Use {@link Plot#addMember(UUID)} (UUID)} (UUID)} calling + * {@link EventDispatcher#callPlayerAdd(PlotPlayer, Plot, UUID, PlayerPlotAddRemoveEvent.Reason)} for each. */ + @Deprecated public void setMembers(final @NonNull Set uuids) { boolean larger = uuids.size() > getMembers().size(); HashSet intersection = new HashSet<>(larger ? getMembers() : uuids); @@ -2302,23 +2312,53 @@ public class Plot { this.setAlias(plot.getAlias()); } for (UUID uuid : this.getTrusted()) { - plot.addTrusted(uuid); + if (eventDispatcher + .callPlayerTrust(null, plot, uuid, PlayerPlotAddRemoveEvent.Reason.MERGE) + .getEventResult() != Result.DENY) { + plot.addTrusted(uuid); + eventDispatcher.callPostTrusted(null, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } } for (UUID uuid : plot.getTrusted()) { - this.addTrusted(uuid); + if (eventDispatcher + .callPlayerTrust(null, this, uuid, PlayerPlotAddRemoveEvent.Reason.MERGE) + .getEventResult() != Result.DENY) { + this.addTrusted(uuid); + eventDispatcher.callPostTrusted(null, this, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } } for (UUID uuid : this.getMembers()) { - plot.addMember(uuid); + if (eventDispatcher + .callPlayerAdd(null, plot, uuid, PlayerPlotAddRemoveEvent.Reason.MERGE) + .getEventResult() != Result.DENY) { + plot.addMember(uuid); + eventDispatcher.callPostAdded(null, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } } for (UUID uuid : plot.getMembers()) { - this.addMember(uuid); + if (eventDispatcher + .callPlayerAdd(null, this, uuid, PlayerPlotAddRemoveEvent.Reason.MERGE) + .getEventResult() != Result.DENY) { + this.addMember(uuid); + eventDispatcher.callPostAdded(null, this, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } } for (UUID uuid : this.getDenied()) { - plot.addDenied(uuid); + if (eventDispatcher + .callPlayerDeny(null, plot, uuid, PlayerPlotAddRemoveEvent.Reason.MERGE) + .getEventResult() != Result.DENY) { + plot.addDenied(uuid); + eventDispatcher.callPostDenied(null, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } } for (UUID uuid : plot.getDenied()) { - this.addDenied(uuid); + if (eventDispatcher + .callPlayerDeny(null, this, uuid, PlayerPlotAddRemoveEvent.Reason.MERGE) + .getEventResult() != Result.DENY) { + this.addDenied(uuid); + eventDispatcher.callPostDenied(null, this, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } } } diff --git a/Core/src/main/java/com/plotsquared/core/plot/PlotArea.java b/Core/src/main/java/com/plotsquared/core/plot/PlotArea.java index d121aee8c..6e6bead5c 100644 --- a/Core/src/main/java/com/plotsquared/core/plot/PlotArea.java +++ b/Core/src/main/java/com/plotsquared/core/plot/PlotArea.java @@ -21,6 +21,7 @@ package com.plotsquared.core.plot; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; +import com.google.inject.Inject; import com.plotsquared.core.PlotSquared; import com.plotsquared.core.collection.QuadMap; import com.plotsquared.core.configuration.ConfigurationNode; @@ -29,6 +30,8 @@ import com.plotsquared.core.configuration.ConfigurationUtil; import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.configuration.caption.TranslatableCaption; import com.plotsquared.core.configuration.file.YamlConfiguration; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; +import com.plotsquared.core.events.Result; import com.plotsquared.core.generator.GridPlotWorld; import com.plotsquared.core.generator.IndependentPlotGenerator; import com.plotsquared.core.inject.annotations.WorldConfig; @@ -47,6 +50,7 @@ import com.plotsquared.core.plot.flag.PlotFlag; import com.plotsquared.core.plot.flag.implementations.DoneFlag; import com.plotsquared.core.queue.GlobalBlockQueue; import com.plotsquared.core.queue.QueueCoordinator; +import com.plotsquared.core.util.EventDispatcher; import com.plotsquared.core.util.MathMan; import com.plotsquared.core.util.PlotExpression; import com.plotsquared.core.util.RegionUtil; @@ -155,6 +159,9 @@ public abstract class PlotArea implements ComponentLike { private QuadMap clusters; private String signMaterial = "OAK_WALL_SIGN"; private String legacySignMaterial = "WALL_SIGN"; + // These will be injected + @Inject + private EventDispatcher eventDispatcher; public PlotArea( final @NonNull String worldName, final @Nullable String id, @@ -1104,9 +1111,44 @@ public abstract class PlotArea implements ComponentLike { final PlotId id = PlotId.of(x, y); final Plot plot = getPlotAbs(id); - plot.setTrusted(trusted); - plot.setMembers(members); - plot.setDenied(denied); + Set currentlyTrusted = plot.getTrusted(); + trusted.forEach(uuid -> { + if (!currentlyTrusted.contains(uuid) && eventDispatcher.callPlayerTrust( + null, + plot, + uuid, + PlayerPlotAddRemoveEvent.Reason.MERGE + ).getEventResult() != Result.DENY) { + plot.addTrusted(uuid); + eventDispatcher.callPostTrusted(null, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } + }); + + Set currentlyAdded = plot.getMembers(); + members.forEach(uuid -> { + if (!currentlyAdded.contains(uuid) && eventDispatcher.callPlayerAdd( + null, + plot, + uuid, + PlayerPlotAddRemoveEvent.Reason.MERGE + ).getEventResult() != Result.DENY) { + plot.addMember(uuid); + eventDispatcher.callPostAdded(null, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } + }); + + Set currentlyDenied = plot.getDenied(); + denied.forEach(uuid -> { + if (!currentlyDenied.contains(uuid) && eventDispatcher.callPlayerDeny( + null, + plot, + uuid, + PlayerPlotAddRemoveEvent.Reason.MERGE + ).getEventResult() != Result.DENY) { + plot.addDenied(uuid); + eventDispatcher.callPostDenied(null, plot, uuid, true, PlayerPlotAddRemoveEvent.Reason.MERGE); + } + }); Plot plot2; if (lx) { diff --git a/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java b/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java index b19a4d751..3d05e03fb 100644 --- a/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java +++ b/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java @@ -29,9 +29,14 @@ import com.plotsquared.core.events.PlayerBuyPlotEvent; import com.plotsquared.core.events.PlayerClaimPlotEvent; import com.plotsquared.core.events.PlayerEnterPlotEvent; import com.plotsquared.core.events.PlayerLeavePlotEvent; +import com.plotsquared.core.events.PlayerPlotAddEvent; +import com.plotsquared.core.events.PlayerPlotAddRemoveEvent; import com.plotsquared.core.events.PlayerPlotDeniedEvent; +import com.plotsquared.core.events.PlayerPlotDenyEvent; import com.plotsquared.core.events.PlayerPlotHelperEvent; import com.plotsquared.core.events.PlayerPlotLimitEvent; +import com.plotsquared.core.events.PlayerPlotRemoveEvent; +import com.plotsquared.core.events.PlayerPlotTrustEvent; import com.plotsquared.core.events.PlayerPlotTrustedEvent; import com.plotsquared.core.events.PlayerTeleportToPlotEvent; import com.plotsquared.core.events.PlotAutoMergeEvent; @@ -51,6 +56,9 @@ import com.plotsquared.core.events.RemoveRoadEntityEvent; import com.plotsquared.core.events.TeleportCause; import com.plotsquared.core.events.post.PostPlayerAutoPlotEvent; import com.plotsquared.core.events.post.PostPlayerBuyPlotEvent; +import com.plotsquared.core.events.post.PostPlayerPlotAddedEvent; +import com.plotsquared.core.events.post.PostPlayerPlotDeniedEvent; +import com.plotsquared.core.events.post.PostPlayerPlotTrustedEvent; import com.plotsquared.core.events.post.PostPlotChangeOwnerEvent; import com.plotsquared.core.events.post.PostPlotClearEvent; import com.plotsquared.core.events.post.PostPlotDeleteEvent; @@ -258,6 +266,7 @@ public class EventDispatcher { return event; } + @Deprecated(forRemoval = true, since = "TODO") public PlayerPlotDeniedEvent callDenied( PlotPlayer initiator, Plot plot, UUID player, boolean added @@ -267,6 +276,7 @@ public class EventDispatcher { return event; } + @Deprecated(forRemoval = true, since = "TODO") public PlayerPlotTrustedEvent callTrusted( PlotPlayer initiator, Plot plot, UUID player, boolean added @@ -276,6 +286,7 @@ public class EventDispatcher { return event; } + @Deprecated(forRemoval = true, since = "TODO") public PlayerPlotHelperEvent callMember( PlotPlayer initiator, Plot plot, UUID player, boolean added @@ -285,6 +296,62 @@ public class EventDispatcher { return event; } + public PostPlayerPlotDeniedEvent callPostDenied( + PlotPlayer initiator, Plot plot, UUID player, boolean added, PlayerPlotAddRemoveEvent.Reason reason + ) { + PostPlayerPlotDeniedEvent event = new PostPlayerPlotDeniedEvent(initiator, plot, player, added, reason); + callEvent(event); + return event; + } + + public PostPlayerPlotTrustedEvent callPostTrusted( + PlotPlayer initiator, Plot plot, UUID player, boolean added, PlayerPlotAddRemoveEvent.Reason reason + ) { + PostPlayerPlotTrustedEvent event = new PostPlayerPlotTrustedEvent(initiator, plot, player, added, reason); + callEvent(event); + return event; + } + + public PostPlayerPlotAddedEvent callPostAdded( + PlotPlayer initiator, Plot plot, UUID player, boolean added, PlayerPlotAddRemoveEvent.Reason reason + ) { + PostPlayerPlotAddedEvent event = new PostPlayerPlotAddedEvent(initiator, plot, player, added, reason); + callEvent(event); + return event; + } + + public PlayerPlotDenyEvent callPlayerDeny( + PlotPlayer initiator, Plot plot, UUID player, PlayerPlotAddRemoveEvent.Reason reason + ) { + PlayerPlotDenyEvent event = new PlayerPlotDenyEvent(initiator, plot, player, reason); + callEvent(event); + return event; + } + + public PlayerPlotTrustEvent callPlayerTrust( + PlotPlayer initiator, Plot plot, UUID player, PlayerPlotAddRemoveEvent.Reason reason + ) { + PlayerPlotTrustEvent event = new PlayerPlotTrustEvent(initiator, plot, player, reason); + callEvent(event); + return event; + } + + public PlayerPlotAddEvent callPlayerAdd( + PlotPlayer initiator, Plot plot, UUID player, PlayerPlotAddRemoveEvent.Reason reason + ) { + PlayerPlotAddEvent event = new PlayerPlotAddEvent(initiator, plot, player, reason); + callEvent(event); + return event; + } + + public PlayerPlotRemoveEvent callPlayerRemove( + PlotPlayer initiator, Plot plot, UUID player, PlayerPlotAddRemoveEvent.Reason reason + ) { + PlayerPlotRemoveEvent event = new PlayerPlotRemoveEvent(initiator, plot, player, reason); + callEvent(event); + return event; + } + public PlotChangeOwnerEvent callOwnerChange( PlotPlayer initiator, Plot plot, UUID oldOwner, UUID newOwner, boolean hasOldOwner