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

- closes #3509

Core/src/main/java/com/plotsquared/core/backup/Backup.java

@@ -18,8 +18,6 @@
  */
 package com.plotsquared.core.backup;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.io.IOException;
@@ -32,14 +30,12 @@ import java.nio.file.Path;
  */
 public class Backup {
 
-    private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + Backup.class.getSimpleName());
-
     private final BackupProfile owner;
     private final long creationTime;
     @Nullable
     private final Path file;
 
-    Backup(final BackupProfile owner, final long creationTime, @Nullable final Path file) {
+    Backup(final BackupProfile owner, final long creationTime, final Path file) {
         this.owner = owner;
         this.creationTime = creationTime;
         this.file = file;
@@ -53,7 +49,7 @@ public class Backup {
             try {
                 Files.deleteIfExists(file);
             } catch (final IOException e) {
-                LOGGER.error("Error deleting back at {}", file, e);
+                e.printStackTrace();
             }
         }
     }

Core/src/main/java/com/plotsquared/core/backup/PlayerBackupProfile.java

@@ -21,15 +21,14 @@ package com.plotsquared.core.backup;
 import com.google.inject.Inject;
 import com.google.inject.assistedinject.Assisted;
 import com.plotsquared.core.configuration.caption.TranslatableCaption;
-import com.plotsquared.core.exception.PlotSquaredException;
+import com.plotsquared.core.player.ConsolePlayer;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.schematic.Schematic;
 import com.plotsquared.core.util.SchematicHandler;
 import com.plotsquared.core.util.task.RunnableVal;
 import com.plotsquared.core.util.task.TaskManager;
-import org.apache.logging.log4j.LogManager;
+import net.kyori.adventure.text.minimessage.MiniMessage;
-import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -52,7 +51,7 @@ import java.util.concurrent.CompletableFuture;
  */
 public class PlayerBackupProfile implements BackupProfile {
 
-    private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + PlayerBackupProfile.class.getSimpleName());
+    static final MiniMessage MINI_MESSAGE = MiniMessage.builder().build();
 
     private final UUID owner;
     private final Plot plot;
@@ -88,7 +87,7 @@ public class PlayerBackupProfile implements BackupProfile {
                 Files.createDirectory(path);
             }
         } catch (final Exception e) {
-            LOGGER.error("Error resolving {} from {}", child, parent, e);
+            e.printStackTrace();
         }
         return path;
     }
@@ -105,7 +104,7 @@ public class PlayerBackupProfile implements BackupProfile {
                     try {
                         Files.createDirectories(path);
                     } catch (IOException e) {
-                        LOGGER.error("Error creating directory {}", path, e);
+                        e.printStackTrace();
                         return Collections.emptyList();
                     }
                 }
@@ -118,11 +117,11 @@ public class PlayerBackupProfile implements BackupProfile {
                             backups.add(
                                     new Backup(this, basicFileAttributes.creationTime().toMillis(), file));
                         } catch (IOException e) {
-                            LOGGER.error("Error getting attributes for file {} to create backup", file, e);
+                            e.printStackTrace();
                         }
                     });
                 } catch (IOException e) {
-                    LOGGER.error("Error walking files from {}", path, e);
+                    e.printStackTrace();
                 }
                 backups.sort(Comparator.comparingLong(Backup::getCreationTime).reversed());
                 return (this.backupCache = backups);
@@ -134,7 +133,7 @@ public class PlayerBackupProfile implements BackupProfile {
     public void destroy() {
         this.listBackups().whenCompleteAsync((backups, error) -> {
             if (error != null) {
-                LOGGER.error("Error while listing backups", error);
+                error.printStackTrace();
             }
             backups.forEach(Backup::delete);
             this.backupCache = null;
@@ -142,12 +141,10 @@ public class PlayerBackupProfile implements BackupProfile {
     }
 
     public @NonNull Path getBackupDirectory() {
-        return resolve(
+        return resolve(resolve(
-                resolve(
+                resolve(backupManager.getBackupPath(), Objects.requireNonNull(plot.getArea().toString(), "plot area id")),
-                        resolve(backupManager.getBackupPath(), Objects.requireNonNull(plot.getArea().toString(), "plot area id")),
+                Objects.requireNonNull(plot.getId().toDashSeparatedString(), "plot id")
-                        Objects.requireNonNull(plot.getId().toDashSeparatedString(), "plot id")
+        ), Objects.requireNonNull(owner.toString(), "owner"));
-                ), Objects.requireNonNull(owner.toString(), "owner")
-        );
     }
 
     @Override
@@ -159,8 +156,7 @@ public class PlayerBackupProfile implements BackupProfile {
                     backups.get(backups.size() - 1).delete();
                 }
                 final List<Plot> plots = Collections.singletonList(plot);
-                final boolean result = this.schematicHandler.exportAll(
+                final boolean result = this.schematicHandler.exportAll(plots, getBackupDirectory().toFile(),
-                        plots, getBackupDirectory().toFile(),
                         "%world%-%id%-" + System.currentTimeMillis(), () ->
                                 future.complete(new Backup(this, System.currentTimeMillis(), null))
                 );
@@ -184,7 +180,7 @@ public class PlayerBackupProfile implements BackupProfile {
                 try {
                     schematic = this.schematicHandler.getSchematic(backup.getFile().toFile());
                 } catch (SchematicHandler.UnsupportedFormatException e) {
-                    LOGGER.error("Unsupported format for backup {}", backup.getFile(), e);
+                    e.printStackTrace();
                 }
                 if (schematic == null) {
                     future.completeExceptionally(new IllegalArgumentException(
@@ -204,9 +200,10 @@ public class PlayerBackupProfile implements BackupProfile {
                                     if (value) {
                                         future.complete(null);
                                     } else {
-                                        future.completeExceptionally(new PlotSquaredException(
+                                        future.completeExceptionally(new RuntimeException(MINI_MESSAGE.escapeTags(
                                                 TranslatableCaption
-                                                        .of("schematics.schematic_paste_failed")));
+                                                        .of("schematics.schematic_paste_failed")
+                                                        .getComponent(ConsolePlayer.getConsole()))));
                                     }
                                 }
                             }

Core/src/main/java/com/plotsquared/core/backup/SimpleBackupManager.java

@@ -32,8 +32,6 @@ import com.plotsquared.core.util.task.TaskManager;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.tag.Tag;
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -49,7 +47,6 @@ import java.util.concurrent.TimeUnit;
 @Singleton
 public class SimpleBackupManager implements BackupManager {
 
-    private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + SimpleBackupManager.class.getSimpleName());
     private final Path backupPath;
     private final boolean automaticBackup;
     private final int backupLimit;
@@ -115,12 +112,7 @@ public class SimpleBackupManager implements BackupManager {
                                 TagResolver.resolver("reason", Tag.inserting(Component.text(throwable.getMessage())))
                         );
                     }
-                    LOGGER.error(
+                    throwable.printStackTrace();
-                            "Error creating backup for plot {};{} and player {}",
-                            plot.getArea(),
-                            plot.getId(),
-                            player == null ? "null" : player.getName(), throwable
-                    );
                 } else {
                     if (player != null) {
                         player.sendMessage(TranslatableCaption.of("backups.backup_automatic_finished"));
@@ -136,7 +128,6 @@ public class SimpleBackupManager implements BackupManager {
         return this.automaticBackup;
     }
 
-    @NonNull
     public Path getBackupPath() {
         return this.backupPath;
     }

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, () -> {
+                    confirm.run(
-                        for (UUID uuid : uuids) {
+                            this, () -> {
-                            if (uuid != DBFunc.EVERYONE) {
+                                for (UUID uuid : uuids) {
-                                if (!plot.removeTrusted(uuid)) {
+                                    if (this.eventDispatcher.callPlayerAdd(
-                                    if (plot.getDenied().contains(uuid)) {
+                                            player,
-                                        plot.removeDenied(uuid);
+                                            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"));
                                 }
-                            }
+                            }, null
-                            plot.addMember(uuid);
+                    );
-                            this.eventDispatcher.callMember(player, plot, uuid, true);
-                            player.sendMessage(TranslatableCaption.of("member.member_added"));
-                        }
-                    }, null);
                 } catch (final Throwable exception) {
                     future.completeExceptionally(exception);
                     return;

Core/src/main/java/com/plotsquared/core/command/Backup.java

@@ -24,7 +24,6 @@ import com.plotsquared.core.backup.BackupProfile;
 import com.plotsquared.core.backup.NullBackupProfile;
 import com.plotsquared.core.backup.PlayerBackupProfile;
 import com.plotsquared.core.configuration.caption.TranslatableCaption;
-import com.plotsquared.core.exception.PlotSquaredException;
 import com.plotsquared.core.permissions.Permission;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
@@ -33,8 +32,6 @@ import com.plotsquared.core.util.task.RunnableVal3;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.tag.Tag;
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.nio.file.Files;
@@ -60,8 +57,6 @@ import java.util.stream.Stream;
         permission = "plots.backup")
 public final class Backup extends Command {
 
-    private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + Backup.class.getSimpleName());
-
     private final BackupManager backupManager;
 
     @Inject
@@ -331,43 +326,20 @@ public final class Backup extends Command {
             if (backupProfile instanceof NullBackupProfile) {
                 player.sendMessage(
                         TranslatableCaption.of("backups.backup_impossible"),
-                        TagResolver.resolver(
+                        TagResolver.resolver("plot", Tag.inserting(
-                                "plot", Tag.inserting(
+                                TranslatableCaption.of("generic.generic_other").toComponent(player)
-                                        TranslatableCaption.of("generic.generic_other").toComponent(player)
+                        ))
-                                )
-                        )
                 );
             } else {
                 backupProfile.listBackups().whenComplete((backups, throwable) -> {
                     if (throwable != null) {
-                        Component reason;
-                        if (throwable instanceof PlotSquaredException pe) {
-                            reason = pe.getCaption().toComponent(player);
-                        } else {
-                            reason = Component.text(throwable.getMessage());
-                        }
                         player.sendMessage(
                                 TranslatableCaption.of("backups.backup_load_failure"),
-                                TagResolver.resolver("reason", Tag.inserting(reason))
+                                TagResolver.resolver("reason", Tag.inserting(Component.text(throwable.getMessage())))
-                        );
-                        LOGGER.error("Error loading player ({}) backup", player.getName(), throwable);
-                        return;
-                    }
-                    if (number < 1 || number > backups.size()) {
-                        player.sendMessage(
-                                TranslatableCaption.of("backups.backup_impossible"),
-                                TagResolver.resolver(
-                                        "plot",
-                                        Tag.inserting(TranslatableCaption
-                                                .of("generic.generic_invalid_choice")
-                                                .toComponent(player))
-                                )
                         );
+                        throwable.printStackTrace();
                     } else {
-                        final com.plotsquared.core.backup.Backup backup =
+                        if (number < 1 || number > backups.size()) {
-                                backups.get(number - 1);
-                        if (backup == null || backup.getFile() == null || !Files
-                                .exists(backup.getFile())) {
                             player.sendMessage(
                                     TranslatableCaption.of("backups.backup_impossible"),
                                     TagResolver.resolver(
@@ -378,23 +350,37 @@ public final class Backup extends Command {
                                     )
                             );
                         } else {
-                            CmdConfirm.addPending(
+                            final com.plotsquared.core.backup.Backup backup =
-                                    player, "/plot backup load " + number,
+                                    backups.get(number - 1);
-                                    () -> backupProfile.restoreBackup(backup, player)
+                            if (backup == null || backup.getFile() == null || !Files
-                                            .whenComplete((n, error) -> {
+                                    .exists(backup.getFile())) {
-                                                if (error != null) {
+                                player.sendMessage(
-                                                    player.sendMessage(
+                                        TranslatableCaption.of("backups.backup_impossible"),
-                                                            TranslatableCaption.of("backups.backup_load_failure"),
+                                        TagResolver.resolver(
-                                                            TagResolver.resolver(
+                                                "plot",
-                                                                    "reason",
+                                                Tag.inserting(TranslatableCaption
-                                                                    Tag.inserting(Component.text(error.getMessage()))
+                                                        .of("generic.generic_invalid_choice")
-                                                            )
+                                                        .toComponent(player))
-                                                    );
+                                        )
-                                                } else {
+                                );
-                                                    player.sendMessage(TranslatableCaption.of("backups.backup_load_success"));
+                            } else {
-                                                }
+                                CmdConfirm.addPending(player, "/plot backup load " + number,
-                                            })
+                                        () -> backupProfile.restoreBackup(backup, player)
-                            );
+                                                .whenComplete((n, error) -> {
+                                                    if (error != null) {
+                                                        player.sendMessage(
+                                                                TranslatableCaption.of("backups.backup_load_failure"),
+                                                                TagResolver.resolver(
+                                                                        "reason",
+                                                                        Tag.inserting(Component.text(error.getMessage()))
+                                                                )
+                                                        );
+                                                    } else {
+                                                        player.sendMessage(TranslatableCaption.of("backups.backup_load_success"));
+                                                    }
+                                                })
+                                );
+                            }
                         }
                     }
                 });

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.isDenied(plotPlayer.getUUID())) {
-                                if (plot.isAdded(plotPlayer.getUUID())) {
+                                    handleKick(plotPlayer, plot);
-                                    continue;
                                 }
-                                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, () -> {
+                confirm.run(
-                    for (UUID uuid : uuids) {
+                        this, () -> {
-                        if (uuid != DBFunc.EVERYONE) {
+                            for (UUID uuid : uuids) {
-                            if (!currentPlot.removeMember(uuid)) {
+                                if (this.eventDispatcher
-                                if (currentPlot.getDenied().contains(uuid)) {
+                                        .callPlayerTrust(player, currentPlot, uuid, PlayerPlotAddRemoveEvent.Reason.COMMAND)
-                                    currentPlot.removeDenied(uuid);
+                                        .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"));
                             }
-                        }
+                        }, null
-                        currentPlot.addTrusted(uuid);
+                );
-                        this.eventDispatcher.callTrusted(player, currentPlot, uuid, true);
-                        player.sendMessage(TranslatableCaption.of("trusted.trusted_added"));
-                    }
-                }, 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/exception/PlotSquaredException.java

@@ -1,62 +0,0 @@
-/*
- * 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.exception;
-
-import com.plotsquared.core.configuration.caption.Caption;
-import com.plotsquared.core.configuration.caption.LocaleHolder;
-
-/**
- * Internal use only. Used to allow adventure captions to be used in an exception
- *
- * @since TODO
- */
-public final class PlotSquaredException extends RuntimeException {
-
-    private final Caption caption;
-
-    /**
-     * Create a new instance with the given caption
-     *
-     * @param caption caption
-     */
-    public PlotSquaredException(Caption caption) {
-        this.caption = caption;
-    }
-
-    /**
-     * Create a new instance with the given caption and cause
-     *
-     * @param caption caption
-     * @param cause   cause
-     */
-    public PlotSquaredException(Caption caption, Exception cause) {
-        super(cause);
-        this.caption = caption;
-    }
-
-    @Override
-    public String getMessage() {
-        return caption.getComponent(LocaleHolder.console());
-    }
-
-    public Caption getCaption() {
-        return caption;
-    }
-
-}

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);
+                Set<UUID> currentlyTrusted = plot.getTrusted();
-                plot.setMembers(members);
+                trusted.forEach(uuid -> {
-                plot.setDenied(denied);
+                    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

Core/src/main/java/com/plotsquared/core/util/SchematicHandler.java

@@ -135,7 +135,6 @@ public abstract class SchematicHandler {
         }
         final String filename;
         final String website;
-        final @Nullable UUID finalUuid = uuid;
         if (uuid == null) {
             uuid = UUID.randomUUID();
             website = Settings.Web.URL + "upload.php?" + uuid;
@@ -145,11 +144,10 @@ public abstract class SchematicHandler {
             filename = file + '.' + extension;
         }
         final URL url;
-        String uri = Settings.Web.URL + "?key=" + uuid + "&type=" + extension;
         try {
-            url = URI.create(uri).toURL();
+            url = URI.create(Settings.Web.URL + "?key=" + uuid + "&type=" + extension).toURL();
         } catch (MalformedURLException e) {
-            LOGGER.error("Malformed URI `{}`", uri, e);
+            e.printStackTrace();
             whenDone.run();
             return;
         }
@@ -195,7 +193,7 @@ public abstract class SchematicHandler {
                 }
                 TaskManager.runTask(whenDone);
             } catch (IOException e) {
-                LOGGER.error("Error while uploading schematic for UUID {}", finalUuid, e);
+                e.printStackTrace();
                 TaskManager.runTask(whenDone);
             }
         });
@@ -390,14 +388,8 @@ public abstract class SchematicHandler {
             }
             queue.enqueue();
         } catch (Exception e) {
+            e.printStackTrace();
             TaskManager.runTask(whenDone);
-            LOGGER.error(
-                    "Error pasting schematic to plot {};{} for player {}",
-                    plot.getArea(),
-                    plot.getId(),
-                    actor == null ? "null" : actor.getName(),
-                    e
-            );
         }
     }
 
@@ -464,7 +456,7 @@ public abstract class SchematicHandler {
                 Clipboard clip = reader.read();
                 return new Schematic(clip);
             } catch (IOException e) {
-                LOGGER.error("Error reading schematic from file {}", file.getAbsolutePath(), e);
+                e.printStackTrace();
             }
         } else {
             throw new UnsupportedFormatException("This schematic format is not recognised or supported.");
@@ -478,7 +470,7 @@ public abstract class SchematicHandler {
             InputStream inputStream = Channels.newInputStream(readableByteChannel);
             return getSchematic(inputStream);
         } catch (IOException e) {
-            LOGGER.error("Error reading schematic from {}", url, e);
+            e.printStackTrace();
         }
         return null;
     }
@@ -494,7 +486,7 @@ public abstract class SchematicHandler {
                 Clipboard clip = schematicReader.read();
                 return new Schematic(clip);
             } catch (IOException e) {
-                LOGGER.error("Error reading schematic", e);
+                e.printStackTrace();
             }
         }
         return null;
@@ -523,7 +515,7 @@ public abstract class SchematicHandler {
             }
             return schematics;
         } catch (JsonParseException | IOException e) {
-            LOGGER.error("Error retrieving saves for UUID {}", uuid, e);
+            e.printStackTrace();
         }
         return null;
     }
@@ -540,7 +532,7 @@ public abstract class SchematicHandler {
                 try (NBTOutputStream nos = new NBTOutputStream(new GZIPOutputStream(output, true))) {
                     nos.writeNamedTag("Schematic", tag);
                 } catch (IOException e1) {
-                    LOGGER.error("Error uploading schematic for UUID {}", uuid, e1);
+                    e1.printStackTrace();
                 }
             }
         }, whenDone);
@@ -564,9 +556,9 @@ public abstract class SchematicHandler {
                 nbtStream.writeNamedTag("Schematic", tag);
             }
         } catch (FileNotFoundException e) {
-            LOGGER.error("Error saving schematic at {}", path, e);
+            e.printStackTrace();
         } catch (IOException e) {
-            LOGGER.error("Error saving schematic at {}", path, e);
+            e.printStackTrace();
             return false;
         }
         return true;
@@ -589,7 +581,7 @@ public abstract class SchematicHandler {
         schematic.put("BlockData", new ByteArrayTag(buffer.toByteArray()));
         schematic.put("BlockEntities", new ListTag(CompoundTag.class, tileEntities));
 
-        if (biomeBuffer.size() == 0 || biomePalette.isEmpty()) {
+        if (biomeBuffer.size() == 0 || biomePalette.size() == 0) {
             return;
         }
 
@@ -741,7 +733,10 @@ public abstract class SchematicHandler {
                                     }
                                     BaseBlock block = aabb.getWorld().getFullBlock(point);
                                     if (block.getNbtData() != null) {
-                                        Map<String, Tag> values = new HashMap<>(block.getNbtData().getValue());
+                                        Map<String, Tag> values = new HashMap<>();
+                                        for (Map.Entry<String, Tag> entry : block.getNbtData().getValue().entrySet()) {
+                                            values.put(entry.getKey(), entry.getValue());
+                                        }
 
                                         // Positions are kept in NBT, we don't want that.
                                         values.remove("x");