feat: implement better add/trust/deny/remove events

- closes #3509

Bukkit/src/main/java/com/plotsquared/bukkit/listener/ProjectileEventListener.java

@@ -47,6 +47,7 @@ import org.bukkit.event.entity.LingeringPotionSplashEvent;
 import org.bukkit.event.entity.PotionSplashEvent;
 import org.bukkit.event.entity.ProjectileHitEvent;
 import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.event.player.PlayerEggThrowEvent;
 import org.bukkit.projectiles.BlockProjectileSource;
 import org.bukkit.projectiles.ProjectileSource;
 import org.checkerframework.checker.nullness.qual.NonNull;
@@ -157,14 +158,26 @@ public class ProjectileEventListener implements Listener {
 
     @EventHandler
     public void onProjectileHit(ProjectileHitEvent event) {
-        Projectile entity = event.getEntity();
+        if (cancelProjectileHit(event.getEntity())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerEggThrow(PlayerEggThrowEvent event) {
+        if (cancelProjectileHit(event.getEgg())) {
+            event.setHatching(false);
+        }
+    }
+
+    private boolean cancelProjectileHit(Projectile entity) {
         Location location = BukkitUtil.adapt(entity.getLocation());
         if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
-            return;
+            return false;
         }
         PlotArea area = location.getPlotArea();
         if (area == null) {
-            return;
+            return false;
         }
         Plot plot = area.getPlot(location);
         ProjectileSource shooter = entity.getShooter();
@@ -172,15 +185,14 @@ public class ProjectileEventListener implements Listener {
             if (!((Player) shooter).isOnline()) {
                 if (plot != null) {
                     if (plot.isAdded(((Player) shooter).getUniqueId()) || plot.getFlag(ProjectilesFlag.class)) {
-                        return;
+                        return false;
                     }
                 } else if (PlotFlagUtil.isAreaRoadFlagsAndFlagEquals(area, ProjectilesFlag.class, true)) {
-                    return;
+                    return false;
                 }
 
                 entity.remove();
-                event.setCancelled(true);
-                return;
+                return true;
             }
 
             PlotPlayer<?> pp = BukkitUtil.adapt((Player) shooter);
@@ -189,38 +201,36 @@ public class ProjectileEventListener implements Listener {
                         Permission.PERMISSION_ADMIN_PROJECTILE_UNOWNED
                 )) {
                     entity.remove();
-                    event.setCancelled(true);
+                    return true;
                 }
-                return;
+                return false;
             }
             if (plot.isAdded(pp.getUUID()) || pp.hasPermission(Permission.PERMISSION_ADMIN_PROJECTILE_OTHER) || plot.getFlag(
                     ProjectilesFlag.class) || (entity instanceof FishHook && plot.getFlag(
                     FishingFlag.class))) {
-                return;
+                return false;
             }
             entity.remove();
-            event.setCancelled(true);
-            return;
+            return true;
         }
         if (!(shooter instanceof Entity) && shooter != null) {
             if (plot == null) {
                 entity.remove();
-                event.setCancelled(true);
-                return;
+                return true;
             }
             Location sLoc =
                     BukkitUtil.adapt(((BlockProjectileSource) shooter).getBlock().getLocation());
             if (!area.contains(sLoc.getX(), sLoc.getZ())) {
                 entity.remove();
-                event.setCancelled(true);
-                return;
+                return true;
             }
             Plot sPlot = area.getOwnedPlotAbs(sLoc);
             if (sPlot == null || !PlotHandler.sameOwners(plot, sPlot)) {
                 entity.remove();
-                event.setCancelled(true);
+                return true;
             }
         }
+        return false;
     }
 
 }

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;

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);
                             }
                         }
                     }

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"),

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);
                         }
                     }
                 }

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);
     }
 

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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);
+    }
+
+}

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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;
+    }
+
+}

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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
+    }
+
+}

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;
     }

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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);
+    }
+
+}

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;
     }

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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);
+    }
+
+}

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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);
+    }
+
+}

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;
     }

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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;
+    }
+
+
+}

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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);
+    }
+
+}

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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);
+    }
+
+}

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 <https://intellectualsites.com>
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+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);
+    }
+
+}

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<UUID> uuids) {
         boolean larger = uuids.size() > getDenied().size();
         HashSet<UUID> 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<UUID> uuids) {
         boolean larger = uuids.size() > getTrusted().size();
         HashSet<UUID> 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<UUID> uuids) {
         boolean larger = uuids.size() > getMembers().size();
         HashSet<UUID> 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);
+            }
         }
     }
 

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<PlotCluster> 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<UUID> 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<UUID> 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<UUID> 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) {

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