Add April Fools event listener for themed interactions

Introduced a new event listener, `AprilFoolsEvent`, to handle April Fools Day interactions with players. This includes good and bad actions that trigger messages, potion effects, and other behaviors based on player activities. Registered the new event listener in `PlayerUtils`.

Jenkinsfile

@@ -0,0 +1,20 @@
+pipeline {
+    agent any
+    stages {
+        stage('Gradle') {
+            steps {
+                sh 'bash gradlew build'
+            }
+        }
+        stage('Archive') {
+            steps {
+                archiveArtifacts artifacts: 'build/libs/', followSymlinks: false
+            }
+        }
+        stage('discord') {
+            steps {
+                discordSend description: "Build: ${BUILD_NUMBER}", showChangeset: true, result: currentBuild.currentResult, title: currentBuild.fullProjectName, webhookURL: env.discordwebhook
+            }
+        }
+    }
+}

build.gradle.kts

@@ -11,7 +11,7 @@ apply<JavaLibraryPlugin>()
 
 java {
     toolchain {
-        languageVersion.set(JavaLanguageVersion.of(17))
+        languageVersion.set(JavaLanguageVersion.of(21))
     }
 }
 
@@ -38,7 +38,7 @@ tasks {
 }
 
 dependencies {
-    compileOnly("com.alttd:Galaxy-API:1.20.4-R0.1-SNAPSHOT") {
+    compileOnly("com.alttd:Galaxy-API:1.21-R0.1-SNAPSHOT") {
         isChanging = true
     }
 }

src/main/java/com/alttd/playerutils/PlayerUtils.java

@@ -3,14 +3,16 @@ package com.alttd.playerutils;
 import com.alttd.playerutils.commands.PlayerUtilsCommand;
 import com.alttd.playerutils.commands.playerutils_subcommands.RotateBlock;
 import com.alttd.playerutils.config.Config;
+import com.alttd.playerutils.config.KeyStorage;
 import com.alttd.playerutils.config.Messages;
-import com.alttd.playerutils.event_listeners.RotateBlockEvent;
+import com.alttd.playerutils.event_listeners.*;
-import com.alttd.playerutils.event_listeners.TeleportEvent;
-import com.alttd.playerutils.event_listeners.XpBottleEvent;
 import com.alttd.playerutils.util.Logger;
+import org.bukkit.Bukkit;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import java.util.concurrent.TimeUnit;
+
 public final class PlayerUtils extends JavaPlugin {
 
     private Logger logger;
@@ -22,10 +24,12 @@ public final class PlayerUtils extends JavaPlugin {
         registerCommands();
         registerEvents();
         reloadConfigs();
+        registerSchedulers();
     }
 
     @Override
     public void onDisable() {
+        KeyStorage.STORAGE.save();
     }
 
     private void registerCommands() {
@@ -36,8 +40,11 @@ public final class PlayerUtils extends JavaPlugin {
         PluginManager pluginManager = getServer().getPluginManager();
         pluginManager.registerEvents(new XpBottleEvent(this, logger), this);
         pluginManager.registerEvents(new TeleportEvent(), this);
+        pluginManager.registerEvents(new GoatHornEvent(logger), this);
+        pluginManager.registerEvents(new LimitArmorStands(this, logger), this);
+        pluginManager.registerEvents(new AprilFoolsEvent(), this);
 
-        RotateBlockEvent rotateBlockEvent = new RotateBlockEvent();
+        RotateBlockEvent rotateBlockEvent = new RotateBlockEvent(logger);
         pluginManager.registerEvents(rotateBlockEvent, this);
         playerUtilsCommand.addSubCommand(new RotateBlock(rotateBlockEvent));
     }
@@ -45,5 +52,11 @@ public final class PlayerUtils extends JavaPlugin {
     public void reloadConfigs() {
         Config.reload(logger);
         Messages.reload(logger);
+        KeyStorage.reload(logger);
+    }
+
+    private void registerSchedulers() {
+        Bukkit.getScheduler().runTaskTimerAsynchronously(this, KeyStorage.STORAGE::save,
+                TimeUnit.MINUTES.toSeconds(5) * 20, TimeUnit.MINUTES.toSeconds(5) * 20);
     }
 }

src/main/java/com/alttd/playerutils/commands/PlayerUtilsCommand.java

@@ -22,7 +22,7 @@ public class PlayerUtilsCommand implements CommandExecutor, TabExecutor {
         PluginCommand command = playerUtils.getCommand("playerutils");
         if (command == null) {
             subCommands = null;
-            logger.severe("Unable to find transfer command.");
+            logger.severe("Unable to find playerutils command.");
             return;
         }
         command.setExecutor(this);
@@ -33,17 +33,18 @@ public class PlayerUtilsCommand implements CommandExecutor, TabExecutor {
                 new Glow(logger),
                 new XPCheque(playerUtils),
                 new XPCalc(),
-                new Reload(playerUtils))
+                new Reload(playerUtils),
+                new Key(logger))
         );
     }
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String cmd, @NotNull String[] args) {
         if (args.length == 0) {
-            commandSender.sendMiniMessage(Messages.HELP.HELP_MESSAGE_WRAPPER.replaceAll("<commands>", subCommands.stream()
+            commandSender.sendRichMessage(Messages.HELP.HELP_MESSAGE_WRAPPER.replaceAll("<commands>", subCommands.stream()
                     .filter(subCommand -> commandSender.hasPermission(subCommand.getPermission()))
                     .map(SubCommand::getHelpMessage)
-                    .collect(Collectors.joining("\n"))), null);
+                    .collect(Collectors.joining("\n"))));
             return true;
         }
 
@@ -52,13 +53,13 @@ public class PlayerUtilsCommand implements CommandExecutor, TabExecutor {
             return false;
 
         if (!commandSender.hasPermission(subCommand.getPermission())) {
-            commandSender.sendMiniMessage(Messages.GENERIC.NO_PERMISSION, Placeholder.parsed("permission", subCommand.getPermission()));
+            commandSender.sendRichMessage(Messages.GENERIC.NO_PERMISSION, Placeholder.parsed("permission", subCommand.getPermission()));
             return true;
         }
 
         boolean executedCorrectly = subCommand.onCommand(commandSender, args);
         if (!executedCorrectly) {
-            commandSender.sendMiniMessage(subCommand.getHelpMessage(), null);
+            commandSender.sendRichMessage(subCommand.getHelpMessage());
         }
         return true;
     }

src/main/java/com/alttd/playerutils/commands/playerutils_subcommands/Glow.java

@@ -41,20 +41,20 @@ public class Glow extends SubCommand {
 
         Player player = playerFromArg.get();
 
-        if (args[1].equalsIgnoreCase("off")) {
-            turnOffGlow(commandSender, player, otherPlayer);
-            return true;
-        }
-
         Scoreboard board = Bukkit.getScoreboardManager().getMainScoreboard();
         board.getTeams().stream()
                 .filter(team -> team.getName().startsWith("Glow"))
                 .filter(team -> team.hasPlayer(player))
                 .forEach(team -> team.removePlayer(player));
 
+        if (args[1].equalsIgnoreCase("off")) {
+            turnOffGlow(commandSender, player, otherPlayer);
+            return true;
+        }
+
         Optional<DyeColor> any = Arrays.stream(DyeColor.values()).filter(chatColor -> chatColor.name().equalsIgnoreCase(args[1])).findAny();
         if (any.isEmpty()) {
-            commandSender.sendMiniMessage(getHelpMessage(), null);
+            commandSender.sendRichMessage(getHelpMessage());
             return true;
         }
 
@@ -75,36 +75,37 @@ public class Glow extends SubCommand {
     private Optional<Player> getTargetPlayer(CommandSender commandSender, String[] args) {
         if (args.length == 2) {
             if (!(commandSender instanceof Player commandPlayer)) {
-                commandSender.sendMiniMessage(Messages.GENERIC.PLAYER_ONLY, null);
+                commandSender.sendRichMessage(Messages.GENERIC.PLAYER_ONLY);
                 return Optional.empty();
             }
             return Optional.of(commandPlayer);
         }
 
         if (!commandSender.hasPermission(getPermission() + ".other")) {
-            commandSender.sendMiniMessage(Messages.GENERIC.NO_PERMISSION, Placeholder.parsed("permission", getPermission() + ".other"));
+            commandSender.sendRichMessage(Messages.GENERIC.NO_PERMISSION, Placeholder.parsed("permission", getPermission() + ".other"));
             return Optional.empty();
         }
         Optional<? extends Player> any = Bukkit.getOnlinePlayers().stream().filter(offlinePlayer -> offlinePlayer.getName().equalsIgnoreCase(args[2])).findAny();
         if (any.isPresent()) {
             return Optional.of(any.get());
         } else {
-            commandSender.sendMiniMessage(Messages.GENERIC.PLAYER_NOT_FOUND, Placeholder.parsed("player", args[2]));
+            commandSender.sendRichMessage(Messages.GENERIC.PLAYER_NOT_FOUND, Placeholder.parsed("player", args[2]));
             return Optional.empty();
         }
     }
 
     private void turnOffGlow(CommandSender commandSender, Player player, boolean otherPlayer) {
-        player.sendMiniMessage(Messages.GLOW.GLOW_OFF, null);
+        player.sendRichMessage(Messages.GLOW.GLOW_OFF);
         player.setGlowing(false);
+
         if (otherPlayer) {
-            commandSender.sendMiniMessage(Messages.GLOW.GLOW_OFF_FOR_PLAYER, Placeholder.component("player", player.name()));
+            commandSender.sendRichMessage(Messages.GLOW.GLOW_OFF_FOR_PLAYER, Placeholder.component("player", player.name()));
         }
     }
 
     private void turnOnGlow(CommandSender commandSender, Player player, Team team, DyeColor dyeColor, boolean otherPlayer) {
         if (team.getScoreboard() == null) {
-            commandSender.sendMiniMessage(Messages.GLOW.UNABLE_TO_GET_SCOREBOARD, null);
+            commandSender.sendRichMessage(Messages.GLOW.UNABLE_TO_GET_SCOREBOARD);
             logger.warning("Unable to get scoreboard for team");
             return;
         }
@@ -114,9 +115,9 @@ public class Glow extends SubCommand {
         player.setScoreboard(team.getScoreboard());
 
         player.setGlowing(true);
-        player.sendMiniMessage(Messages.GLOW.GLOW_ON, Placeholder.parsed("color", dyeColor.name()));
+        player.sendRichMessage(Messages.GLOW.GLOW_ON, Placeholder.parsed("color", dyeColor.name()));
         if (otherPlayer) {
-            commandSender.sendMiniMessage(Messages.GLOW.GLOW_ON_FOR_PLAYER, TagResolver.resolver(
+            commandSender.sendRichMessage(Messages.GLOW.GLOW_ON_FOR_PLAYER, TagResolver.resolver(
                     Placeholder.parsed("color", dyeColor.name()),
                     Placeholder.component("player", player.name())
             ));

src/main/java/com/alttd/playerutils/commands/playerutils_subcommands/Key.java

@@ -0,0 +1,87 @@
+package com.alttd.playerutils.commands.playerutils_subcommands;
+
+import com.alttd.playerutils.commands.SubCommand;
+import com.alttd.playerutils.config.Config;
+import com.alttd.playerutils.config.KeyStorage;
+import com.alttd.playerutils.config.Messages;
+import com.alttd.playerutils.util.Logger;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+import java.util.UUID;
+
+public class Key extends SubCommand {
+
+    private final Logger logger;
+
+    public Key(Logger logger) {
+        this.logger = logger;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, String[] args) {
+        if (!(commandSender instanceof Player player)) {
+            commandSender.sendRichMessage(Messages.GENERIC.PLAYER_ONLY);
+            return true;
+        }
+
+        if (args.length != 2) {
+            return false;
+        }
+
+        String crate = args[1].toLowerCase();
+        if (!Config.KEY.CRATES.containsKey(crate)) {
+            commandSender.sendRichMessage(Messages.KEY.CRATE_NOT_EXIST, Placeholder.parsed("crate", crate));
+            return true;
+        }
+
+        UUID uuid = player.getUniqueId();
+        Object2IntOpenHashMap<UUID> crateMap = KeyStorage.STORAGE.KEYS.get(crate);
+        int totalKeys = Config.KEY.CRATES.getOrDefault(crate, 0);
+        int keys = crateMap.getOrDefault(uuid, 0);
+        if (keys >= totalKeys) {
+            commandSender.sendRichMessage(Messages.KEY.RETRIEVED_ALL_KEYS, TagResolver.resolver(
+                    Placeholder.parsed("crate", crate),
+                    Placeholder.parsed("keys", String.valueOf(keys))));
+            return true;
+        }
+
+        crateMap.addTo(uuid, 1);
+        logger.info(String.format("Gave %s one key for %s", player.getName(), crate));
+        commandSender.getServer().dispatchCommand(Bukkit.getConsoleSender(), String.format("crate give v %s 1 %s", crate, player.getName()));
+        if (keys + 1 == totalKeys) {
+            commandSender.sendRichMessage(Messages.KEY.GAVE_FINAL_KEY, TagResolver.resolver(
+                    Placeholder.parsed("crate", crate),
+                    Placeholder.parsed("keys", String.valueOf(keys + 1))));
+        } else {
+            commandSender.sendRichMessage(Messages.KEY.GAVE_KEY, TagResolver.resolver(
+                    Placeholder.parsed("crate", crate),
+                    Placeholder.parsed("keys", String.valueOf(keys + 1)),
+                    Placeholder.parsed("total_keys", String.valueOf(totalKeys))));
+        }
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "key";
+    }
+
+    @Override
+    public List<String> getTabComplete(CommandSender commandSender, String[] args) {
+        if (args.length > 2) {
+            return List.of();
+        }
+        return Config.KEY.CRATES.keySet().stream().toList();
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return Messages.HELP.KEY;
+    }
+}

src/main/java/com/alttd/playerutils/commands/playerutils_subcommands/Reload.java

@@ -18,7 +18,7 @@ public class Reload extends SubCommand {
     @Override
     public boolean onCommand(CommandSender commandSender, String[] args) {
         playerUtils.reloadConfigs();
-        commandSender.sendMiniMessage(Messages.RELOAD.RELOADED, null);
+        commandSender.sendRichMessage(Messages.RELOAD.RELOADED);
         return true;
     }
 

src/main/java/com/alttd/playerutils/commands/playerutils_subcommands/RotateBlock.java

@@ -19,15 +19,15 @@ public class RotateBlock extends SubCommand {
     @Override
     public boolean onCommand(CommandSender commandSender, String[] args) {
         if (!(commandSender instanceof Player player)) {
-            commandSender.sendMiniMessage(Messages.GENERIC.PLAYER_ONLY, null);
+            commandSender.sendRichMessage(Messages.GENERIC.PLAYER_ONLY);
             return true;
         }
 
         boolean enabled = rotateBlockEvent.toggleRotate(player.getUniqueId());
         if (enabled)
-            commandSender.sendMiniMessage(Messages.ROTATE_BLOCK.ENABLED, null);
+            commandSender.sendRichMessage(Messages.ROTATE_BLOCK.ENABLED);
         else
-            commandSender.sendMiniMessage(Messages.ROTATE_BLOCK.DISABLED, null);
+            commandSender.sendRichMessage(Messages.ROTATE_BLOCK.DISABLED);
         return true;
     }
 

src/main/java/com/alttd/playerutils/commands/playerutils_subcommands/XPCalc.java

@@ -34,7 +34,7 @@ public class XPCalc extends SubCommand {
             startingLevel++;
         }
 
-        commandSender.sendMiniMessage(Messages.XP_CALC.XP_NEEDED, Placeholder.parsed("xp_needed", String.valueOf(totalXpNeeded)));
+        commandSender.sendRichMessage(Messages.XP_CALC.XP_NEEDED, Placeholder.parsed("xp_needed", String.valueOf(totalXpNeeded)));
         return true;
     }
 

src/main/java/com/alttd/playerutils/commands/playerutils_subcommands/XPCheque.java

@@ -31,7 +31,7 @@ public class XPCheque extends SubCommand {
     @Override
     public boolean onCommand(CommandSender commandSender, String[] args) {
         if (!(commandSender instanceof Player player)) {
-            commandSender.sendMiniMessage(Messages.GENERIC.PLAYER_ONLY, null);
+            commandSender.sendRichMessage(Messages.GENERIC.PLAYER_ONLY);
             return true;
         }
 
@@ -48,7 +48,7 @@ public class XPCheque extends SubCommand {
         }
 
         if (amount > 64 || amount < 1) {
-            commandSender.sendMiniMessage(Messages.XP_CHEQUE.INVALID_AMOUNT, null);
+            commandSender.sendRichMessage(Messages.XP_CHEQUE.INVALID_AMOUNT);
             return true;
         }
 
@@ -60,24 +60,24 @@ public class XPCheque extends SubCommand {
         }
 
         if ((xpValue <= 0)) {
-            commandSender.sendMiniMessage(Messages.XP_CHEQUE.NEGATIVE, null);
+            commandSender.sendRichMessage(Messages.XP_CHEQUE.NEGATIVE);
             return true;
         }
 
         int totalExperience = player.getTotalExperience();
         if (totalExperience < (xpValue * amount)) {
-            commandSender.sendMiniMessage(Messages.XP_CHEQUE.NOT_ENOUGH_XP, Placeholder.parsed("xp", String.valueOf(totalExperience)));
+            commandSender.sendRichMessage(Messages.XP_CHEQUE.NOT_ENOUGH_XP, Placeholder.parsed("xp", String.valueOf(totalExperience)));
             return true;
         }
 
         ItemStack heldItem = player.getInventory().getItemInMainHand();
         if (!heldItem.getType().equals(Material.GLASS_BOTTLE)) {
-            commandSender.sendMiniMessage(Messages.XP_CHEQUE.NOT_HOLDING_BOTTLE, null);
+            commandSender.sendRichMessage(Messages.XP_CHEQUE.NOT_HOLDING_BOTTLE);
             return true;
         }
 
         if (heldItem.getAmount() < amount) {
-            commandSender.sendMiniMessage(Messages.XP_CHEQUE.NOT_ENOUGH_BOTTLE, Placeholder.parsed("amount", String.valueOf(amount)));
+            commandSender.sendRichMessage(Messages.XP_CHEQUE.NOT_ENOUGH_BOTTLE, Placeholder.parsed("amount", String.valueOf(amount)));
             return true;
         }
 
@@ -122,7 +122,7 @@ public class XPCheque extends SubCommand {
         NamespacedKey customXp = NamespacedKey.fromString("custom_xp", playerUtils);
 
         if (customXp == null) {
-            player.sendMiniMessage(Messages.XP_CHEQUE.FAILED_STORAGE, null);
+            player.sendRichMessage(Messages.XP_CHEQUE.FAILED_STORAGE);
             return Optional.empty();
         }
         persistentDataContainer.set(customXp, PersistentDataType.INTEGER, xpValue);

src/main/java/com/alttd/playerutils/config/Config.java

@@ -1,8 +1,12 @@
 package com.alttd.playerutils.config;
 
 import com.alttd.playerutils.util.Logger;
+import org.bukkit.configuration.ConfigurationSection;
 
 import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
 
 public class Config extends AbstractConfig{
 
@@ -11,8 +15,8 @@ public class Config extends AbstractConfig{
 
     Config(Logger logger) {
         super(
-                new File(System.getProperty("user.home") + File.separator
+                new File(File.separator
-                        + "share" + File.separator
+                        + "mnt" + File.separator
                         + "configs" + File.separator
                         + "PlayerUtils"),
                 "config.yml", logger);
@@ -36,4 +40,46 @@ public class Config extends AbstractConfig{
             WARNINGS = config.getBoolean(prefix, "warnings", WARNINGS);
         }
     }
+
+    public static class KEY {
+        private static final String prefix = "key.";
+        public static HashMap<String, Integer> CRATES = new HashMap<>();
+
+        @SuppressWarnings("unused")
+        private static void load() {
+            CRATES.clear();
+            ConfigurationSection configurationSection = config.getConfigurationSection(prefix.substring(0, prefix.length() - 1));
+            if (configurationSection == null) {
+                config.logger.warning("No keys configured, adding default");
+                config.set(prefix, "dailyvotecrate", 0);
+                config.set(prefix, "weeklyvotecrate", 0);
+                config.set(prefix, "questcrate", 0);
+                return;
+            }
+            Set<String> keys = configurationSection.getKeys(false);
+            for (String key : keys) {
+                CRATES.put(key, config.getInt(prefix, key, 0));
+            }
+        }
+    }
+
+    public static class ARMOR_STAND_LIMIT {
+        private static final String prefix = "armor_stand_limit.";
+
+        public static HashMap<String, Integer> LIMIT = new HashMap<>();
+
+        @SuppressWarnings("unused")
+        private static void load() {
+            LIMIT.clear();
+            ConfigurationSection configurationSection = config.getConfigurationSection(prefix.substring(0, prefix.length() - 1));
+            if (configurationSection == null) {
+                config.logger.warning("No limits configured, adding default");
+                config.set(prefix, "default", 10);
+            }
+            Set<String> limits = configurationSection.getKeys(false);
+            for (String key : limits) {
+                LIMIT.put(key, config.getInt(prefix, key, 10));
+            }
+        }
+    }
 }

src/main/java/com/alttd/playerutils/config/KeyStorage.java

@@ -0,0 +1,71 @@
+package com.alttd.playerutils.config;
+
+import com.alttd.playerutils.util.Logger;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import org.bukkit.configuration.ConfigurationSection;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+public class KeyStorage extends AbstractConfig {
+
+    static KeyStorage config;
+    private final Logger logger;
+
+    public KeyStorage(Logger logger) {
+        super(
+                new File(File.separator
+                         + "mnt" + File.separator
+                         + "configs" + File.separator
+                         + "PlayerUtils"),
+                "key_storage.yml", logger);
+        this.logger = logger;
+    }
+
+    public static void reload(Logger logger) {
+        logger.info("Reloading key storage");
+        config = new KeyStorage(logger);
+        config.readConfig(KeyStorage.class, null);
+    }
+
+    public static class STORAGE {
+        private static final String prefix = "storage.";
+
+        public static HashMap<String, Object2IntOpenHashMap<UUID>> KEYS = new HashMap<>();
+
+        @SuppressWarnings("unused")
+        private static void load() {
+            save();
+            KEYS.clear();
+            for (String crate : Config.KEY.CRATES.keySet()) {
+                Object2IntOpenHashMap<UUID> count = new Object2IntOpenHashMap<>();
+                ConfigurationSection configurationSection = config.getConfigurationSection(prefix + crate);
+                if (configurationSection == null) {
+                    config.logger.info(String.format("No section yet for crate %s", crate));
+                    KEYS.put(crate, count);
+                    continue;
+                }
+                List<UUID> uuids = configurationSection.getKeys(false).stream().map(UUID::fromString).toList();
+                if (uuids.isEmpty()) {
+                    config.logger.info(String.format("No keys yet for crate %s", crate));
+                    KEYS.put(crate, count);
+                    continue;
+                }
+                for (UUID uuid : uuids) {
+                    int keys = config.getInt(prefix + crate + ".", uuid.toString(), 0);
+                    count.put(uuid, keys);
+                }
+                KEYS.put(crate, count);
+            }
+        }
+
+        public synchronized static void save() {
+            config.logger.info("Saving KeyStorage");
+            KEYS.keySet()
+                    .forEach(crate -> KEYS.get(crate)
+                            .forEach((uuid, keys) -> config.set(prefix + crate + ".", uuid.toString(), keys)));
+        }
+    }
+}

src/main/java/com/alttd/playerutils/config/Messages.java

@@ -1,6 +1,7 @@
 package com.alttd.playerutils.config;
 
 import com.alttd.playerutils.util.Logger;
+import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
 import java.util.List;
@@ -11,8 +12,8 @@ public class Messages extends AbstractConfig {
 
     Messages(Logger logger) {
         super(
-                new File(System.getProperty("user.home") + File.separator
+                new File(File.separator
-                        + "share" + File.separator
+                        + "mnt" + File.separator
                         + "configs" + File.separator
                         + "PlayerUtils"),
                 "messages.yml", logger);
@@ -34,6 +35,7 @@ public class Messages extends AbstractConfig {
         public static String XP_CALC = "<green>Calculate the amount of XP between levels: <gold>/pu xpcalc <from> <to></gold></green>";
         public static String RELOAD = "<green>Reload the configs for PlayerUtils: <gold>/pu reload</gold></green>";
         public static String ROTATE_BLOCK = "<green>Enable rotating blocks with a blaze rod: <gold>/pu rotateblock</gold></green>";
+        public static String KEY = "<green>Receive a key that you are owed: <gold>/pu key</gold></green>";
 
         @SuppressWarnings("unused")
         private static void load() {
@@ -138,4 +140,21 @@ public class Messages extends AbstractConfig {
             DISABLED = config.getString(prefix, "disabled", DISABLED);
         }
     }
+
+    public static class KEY {
+        private static final String prefix = "pu-command.key.";
+
+        public static String CRATE_NOT_EXIST = "<red>There is no crate called <crate></green>";
+        public static String RETRIEVED_ALL_KEYS = "<red>You already retrieved all <keys> keys for the <crate>.</red>";
+        public static String GAVE_KEY = "<green>You received a <crate> key. You have received <keys> out of <total_keys> keys. Make sure to use your key before requesting another</green>";
+        public static String GAVE_FINAL_KEY = "<green>You received your final <crate> key. You have received a total of <keys> keys for this crate.</green>";
+
+        @SuppressWarnings("unused")
+        private static void load() {
+            CRATE_NOT_EXIST = config.getString(prefix, "crate-not-exist", CRATE_NOT_EXIST);
+            RETRIEVED_ALL_KEYS = config.getString(prefix, "retrieved-all-keys", RETRIEVED_ALL_KEYS);
+            GAVE_KEY = config.getString(prefix, "gave-key", GAVE_KEY);
+            GAVE_FINAL_KEY = config.getString(prefix, "gave-final-key", GAVE_FINAL_KEY);
+        }
+    }
 }

src/main/java/com/alttd/playerutils/event_listeners/AprilFoolsEvent.java

@@ -0,0 +1,226 @@
+package com.alttd.playerutils.event_listeners;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Material;
+import org.bukkit.Tag;
+import org.bukkit.block.Block;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityBreedEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.player.PlayerBucketEntityEvent;
+import org.bukkit.event.player.PlayerFishEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffectType;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.LocalDate;
+import java.time.ZoneOffset;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+public class AprilFoolsEvent implements Listener {
+
+    MiniMessage miniMessage = MiniMessage.miniMessage();
+
+    List<Component> happyMessages = List.of(
+            miniMessage.deserialize("<green>You have a sudden urge of calmness and peace</green>"),
+            miniMessage.deserialize("<green>Mother nature is pleased and graces us with her beauty!</green>"),
+            miniMessage.deserialize("<green>The gentle breeze feels like a soothing hug from nature.</green>")
+    );
+
+    List<Component> angryMessages = List.of(
+            miniMessage.deserialize("<red>Something seems off...</red>"),
+            miniMessage.deserialize("<red>Mother nature is angry and furious with you!</red>"),
+            miniMessage.deserialize("<red>The wind picks up, carrying the anger of the earth.</red>")
+    );
+    
+    private final List<PotionEffectType> badEffects = List.of(PotionEffectType.BLINDNESS, PotionEffectType.NAUSEA,
+            PotionEffectType.LEVITATION, PotionEffectType.DARKNESS, PotionEffectType.MINING_FATIGUE, PotionEffectType.SLOWNESS);
+
+    private final List<PotionEffectType> goodEffects = List.of(PotionEffectType.ABSORPTION, PotionEffectType.GLOWING,
+            PotionEffectType.HEALTH_BOOST, PotionEffectType.HERO_OF_THE_VILLAGE, PotionEffectType.LUCK, PotionEffectType.REGENERATION,
+            PotionEffectType.REGENERATION, PotionEffectType.RESISTANCE, PotionEffectType.SATURATION, PotionEffectType.STRENGTH);
+
+    private final List<Material> badBlocks = List.of(Material.SHORT_GRASS, Material.TALL_GRASS, Material.SEAGRASS,
+            Material.TALL_SEAGRASS, Material.LILY_PAD, Material.KELP, Material.KELP_PLANT, Material.BEEHIVE,
+            Material.BAMBOO, Material.MOSS_BLOCK, Material.CACTUS, Material.SMALL_DRIPLEAF, Material.BIG_DRIPLEAF);
+
+    private final List<Material> goodBlocks = List.of(Material.CACTUS, Material.AZALEA, Material.FLOWERING_AZALEA);
+
+    private final HashMap<UUID, Integer> goodActions = new HashMap<>();
+
+    private final HashMap<UUID, Integer> badActions = new HashMap<>();
+
+    private boolean isFlower(Material material) {
+        return Tag.FLOWERS.isTagged(material);
+    }
+
+    private boolean isLog(Material material) {
+        return Tag.LOGS.isTagged(material);
+    }
+
+    private boolean isLeaves(Material material) {
+        return Tag.LEAVES.isTagged(material);
+    }
+
+    private boolean isBadBlock(Material material) {
+        return badBlocks.contains(material) || isFlower(material) || isLog(material) || isLeaves(material);
+    }
+
+    private boolean isGoodBlock(@NotNull Material material) {
+        return goodBlocks.contains(material) || isFlower(material);
+    }
+
+    private boolean isNotAprilFools() {
+        LocalDate currentDate = LocalDate.now(ZoneOffset.UTC);
+        return currentDate.getMonthValue() != 4 || currentDate.getDayOfMonth() != 1;
+    }
+
+    /**
+     * Determines whether the provided count exceeds a randomly generated limit.
+     * The limit is generated as a random integer between 100 and 300, inclusive.
+     *
+     * @param count the value to be compared against the generated random limit
+     * @return true if the count is greater than the random limit; false otherwise
+     */
+    private boolean underLimit(int count) {
+        int randomValue = 100 + (int) (Math.random() * 201);
+        return count <= randomValue;
+    }
+
+    private Component getRandomMessage(@NotNull List<Component> messages) {
+        return messages.get((int) (Math.random() * messages.size()));
+    }
+
+    private PotionEffectType getRandomEffect(@NotNull List<PotionEffectType> potionEffectTypes) {
+        return potionEffectTypes.get((int) (Math.random() * potionEffectTypes.size()));
+    }
+
+    @EventHandler
+    public void onBlockPlace(BlockPlaceEvent event) {
+        if (isNotAprilFools()) {
+            return;
+        }
+        if (!isGoodBlock(event.getBlock().getType())) {
+            return;
+        }
+        runGoodAction(event.getPlayer());
+    }
+
+    @EventHandler
+    public void onGrassBlockBoneMealed(PlayerInteractEvent event) {
+        if (isNotAprilFools()) {
+            return;
+        }
+
+        if (!event.getAction().isRightClick()) {
+            return;
+        }
+
+        ItemStack itemInHand = event.getPlayer().getInventory().getItemInMainHand();
+        if (itemInHand.getType() != Material.BONE_MEAL) {
+            return;
+        }
+
+        Block clickedBlock = event.getClickedBlock();
+        if (clickedBlock == null || clickedBlock.getType() != Material.GRASS_BLOCK) {
+            return;
+        }
+
+        if (event.getHand() != EquipmentSlot.HAND) {
+            return;
+        }
+        runGoodAction(event.getPlayer());
+    }
+
+    @EventHandler
+    public void onAnimalBred(EntityBreedEvent event) {
+        if (isNotAprilFools()) {
+            return;
+        }
+        if (!(event.getBreeder() instanceof Player player)) {
+            return;
+        }
+
+        runGoodAction(player);
+    }
+
+    private void runGoodAction(@NotNull Player player) {
+        goodActions.merge(player.getUniqueId(), 1, Integer::sum);
+        if (underLimit(goodActions.get(player.getUniqueId()))) {
+            return;
+        }
+        player.sendMessage(getRandomMessage(happyMessages));
+        player.addPotionEffect(getRandomEffect(goodEffects).createEffect(60 * 20, 1));
+        goodActions.put(player.getUniqueId(), 0);
+    }
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+        if (isNotAprilFools()) {
+            return;
+        }
+        if (!isBadBlock(event.getBlock().getType())) {
+            return;
+        }
+        Player player = event.getPlayer();
+        runBadAction(player);
+    }
+
+    @EventHandler
+    public void onAnimalKilled(EntityDeathEvent event) {
+        if (isNotAprilFools()) {
+            return;
+        }
+        LivingEntity entity = event.getEntity();
+        if (entity.getKiller() == null) {
+            return;
+        }
+
+        if (entity instanceof Monster) {
+            return;
+        }
+
+        Player player = entity.getKiller();
+        runBadAction(player);
+    }
+
+    @EventHandler
+    public void onFishCollected(PlayerBucketEntityEvent event) {
+        if (isNotAprilFools()) {
+            return;
+        }
+        Player player = event.getPlayer();
+        runBadAction(player);
+    }
+
+    @EventHandler
+    public void onPlayerFish(PlayerFishEvent event) {
+        if (isNotAprilFools()) {
+            return;
+        }
+        Player player = event.getPlayer();
+        runBadAction(player);
+    }
+
+    private void runBadAction(@NotNull Player player) {
+        badActions.merge(player.getUniqueId(), 1, Integer::sum);
+        if (underLimit(badActions.get(player.getUniqueId()))) {
+            return;
+        }
+        player.sendMessage(getRandomMessage(angryMessages));
+        player.addPotionEffect(getRandomEffect(badEffects).createEffect(10 * 20, 1));
+        badActions.put(player.getUniqueId(), 0);
+    }
+
+}

src/main/java/com/alttd/playerutils/event_listeners/GoatHornEvent.java

@@ -0,0 +1,53 @@
+package com.alttd.playerutils.event_listeners;
+
+import com.alttd.playerutils.util.Logger;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.concurrent.TimeUnit;
+
+public class GoatHornEvent implements Listener {
+
+    private final Logger logger;
+
+    public GoatHornEvent(Logger logger) {
+        this.logger = logger;
+    }
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        ItemStack item = event.getItem();
+        if (item == null) {
+            return;
+        }
+
+        if (!event.getItem().getType().equals(Material.GOAT_HORN)) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        if (player.getCooldown(item.getType()) > 0) {
+            event.setCancelled(true);
+            return;
+        }
+
+        Location spawn = player.getLocation().clone();
+        spawn.set(0, player.getY(), 0);
+
+
+        if (player.getLocation().distance(spawn) > 250) {
+            logger.info(String.format("Player %s with uuid %s used a goat horn", player.getName(), player.getUniqueId()));
+            return;
+        }
+
+        logger.info(String.format("Player %s with uuid %s used a goat horn in spawn", player.getName(), player.getUniqueId()));
+
+        player.setCooldown(Material.GOAT_HORN, (int) TimeUnit.MINUTES.toSeconds(5) * 20);
+    }
+
+}

src/main/java/com/alttd/playerutils/event_listeners/LimitArmorStands.java

@@ -0,0 +1,148 @@
+package com.alttd.playerutils.event_listeners;
+
+import com.alttd.playerutils.PlayerUtils;
+import com.alttd.playerutils.config.Config;
+import com.alttd.playerutils.util.Logger;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.title.Title;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.block.Block;
+import org.bukkit.block.TrialSpawner;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+public class LimitArmorStands implements Listener {
+
+    private final PlayerUtils playerUtils;
+    private final Logger logger;
+
+    public LimitArmorStands(PlayerUtils playerUtils, Logger logger) {
+        this.playerUtils = playerUtils;
+        this.logger = logger;
+    }
+
+    @FunctionalInterface
+    private interface ArmorStandCountConsumer {
+        void apply(int armorStandCount, @NotNull Player player, @NotNull NamespacedKey namespacedKey,
+                @NotNull PersistentDataContainer persistentDataContainer);
+    }
+
+    @FunctionalInterface
+    private interface TrialSpawnerTimerConsumer {
+        void apply(int ticks, @NotNull Player player);
+    }
+
+    @EventHandler
+    public void onPlayerInteractEvent(PlayerInteractEvent event) {
+        handleArmorStandPlacing(event, (armorStandCount, player, namespacedKey, persistentDataContainer) -> {
+            int max = 0;
+            for (String permission : Config.ARMOR_STAND_LIMIT.LIMIT.keySet()) {
+                if (player.hasPermission("pu.limit." + permission)) {
+                    max = Math.max(max, Config.ARMOR_STAND_LIMIT.LIMIT.get(permission));
+                }
+            }
+            if (armorStandCount >= max) {
+                event.setCancelled(true);
+                player.sendRichMessage("<red>You can not place more than <max> armor stands in a chunk</red>",
+                        Placeholder.parsed("max", String.valueOf(max)));
+                return;
+            }
+            persistentDataContainer.set(namespacedKey, PersistentDataType.INTEGER, ++armorStandCount);
+        });
+
+        if (event.getPlayer().hasPermission("pu.trial_spawner.cooldown")) {
+            handleRightClickTrialSpawner(event, (ticks, player) -> {
+                MiniMessage miniMessage = MiniMessage.miniMessage();
+                Title title = Title.title(Component.empty(),
+                        miniMessage.deserialize("<green>Cooldown <red><seconds></red></green>",
+                                Placeholder.parsed("seconds", String.valueOf(ticks / 20))));
+                player.showTitle(title);
+            });
+        }
+    }
+
+    private void handleArmorStandPlacing(PlayerInteractEvent event, ArmorStandCountConsumer consumer) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        if (!event.getMaterial().equals(Material.ARMOR_STAND)) {
+            return;
+        }
+        if (event.getClickedBlock() == null) {
+            return;
+        }
+        Player player = event.getPlayer();;
+        Chunk chunk = event.getClickedBlock().getChunk();
+        NamespacedKey namespacedKey = NamespacedKey.fromString("armor_stand_count", playerUtils);
+        if (namespacedKey == null) {
+            event.setCancelled(true);
+            logger.warning("Unable to retrieve name spaced key for armor stand count.");
+            player.sendRichMessage("<red>Something went wrong while checking the armor stand count. " +
+                    "You will not be able to place this until this is fixed. Please contact a staff member</red>");
+            return;
+        }
+        PersistentDataContainer persistentDataContainer = chunk.getPersistentDataContainer();
+        if (!persistentDataContainer.has(namespacedKey, PersistentDataType.INTEGER)) {
+            persistentDataContainer.set(namespacedKey, PersistentDataType.INTEGER, countArmorStands(chunk));
+        }
+        Integer armorStandCount = persistentDataContainer.get(namespacedKey, PersistentDataType.INTEGER);
+        if (armorStandCount == null) {
+            event.setCancelled(true);
+            logger.warning("Unable to retrieve armor stand count.");
+            player.sendRichMessage("<red>Something went wrong while checking the armor stand count. " +
+                    "You will not be able to place this until this is fixed. Please contact a staff member</red>");
+            return;
+        }
+        consumer.apply(armorStandCount, event.getPlayer(), namespacedKey, persistentDataContainer);
+    }
+
+    private void handleRightClickTrialSpawner(PlayerInteractEvent event, TrialSpawnerTimerConsumer consumer) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        if (!event.getMaterial().equals(Material.AIR)) {
+            return;
+        }
+        if (event.getClickedBlock() == null) {
+            return;
+        }
+
+        Block block = event.getClickedBlock();
+        if (!block.getType().equals(Material.TRIAL_SPAWNER)) {
+            return;
+        }
+        if (!(block instanceof TrialSpawner trialSpawner)) {
+            return;
+        }
+        if (!(trialSpawner.getBlockData() instanceof org.bukkit.block.data.type.TrialSpawner trialSpawnerData)) {
+            return;
+        }
+        Player player = event.getPlayer();
+        if (!trialSpawnerData.getTrialSpawnerState().equals(org.bukkit.block.data.type.TrialSpawner.State.INACTIVE)) {
+            consumer.apply(0, player);
+            return;
+        }
+
+        consumer.apply(trialSpawner.getCooldownLength(), player);
+    }
+
+    private int countArmorStands(Chunk chunk) {
+        return (int) Arrays.stream(chunk.getEntities())
+                .filter(entity -> entity.getType().equals(EntityType.ARMOR_STAND))
+                .count();
+    }
+
+}

src/main/java/com/alttd/playerutils/event_listeners/RotateBlockEvent.java

@@ -1,5 +1,6 @@
 package com.alttd.playerutils.event_listeners;
 
+import com.alttd.playerutils.util.Logger;
 import org.bukkit.Axis;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
@@ -23,8 +24,13 @@ import java.util.stream.Collectors;
 public class RotateBlockEvent implements Listener {
 
     private final HashSet<UUID> rotateEnabled = new HashSet<>();
+    private final Logger logger;
     private static final List<BlockFace> VALID_FOUR_STATES = List.of(BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST);
 
+    public RotateBlockEvent(Logger logger) {
+        this.logger = logger;
+    }
+
 
     public synchronized boolean toggleRotate(UUID uuid) {
         if (rotateEnabled.contains(uuid)) {
@@ -55,7 +61,14 @@ public class RotateBlockEvent implements Listener {
             return;
 
         Material type = block.getType();
-        if (Tag.STAIRS.isTagged(type)) {
+        logger.debug(String.format("Material %s with action %s", type, event.getAction().isLeftClick() ? "left click" : "right click"));
+        if (type.equals(Material.IRON_TRAPDOOR) && event.getAction().isLeftClick()) {
+            event.setCancelled(true);
+            toggleTrapDoor(block, player);
+        } else if (type.equals(Material.BIG_DRIPLEAF) && event.getAction().isLeftClick()) {
+            event.setCancelled(true);
+            toggleDripLeaf(block, player);
+        } else if (Tag.STAIRS.isTagged(type)) {
             event.setCancelled(true);
             rotateStairs(block, player);
         } else if (Tag.WALLS.isTagged(type)) {
@@ -67,12 +80,6 @@ public class RotateBlockEvent implements Listener {
         } else if(Tag.RAILS.isTagged(type)) {
             event.setCancelled(true);
             toggleRails(block, player);
-        } else if (type.equals(Material.IRON_TRAPDOOR) && event.getAction().isLeftClick()) {
-            event.setCancelled(true);
-            toggleTrapDoor(block, player);
-        } else if (Tag.BIG_DRIPLEAF_PLACEABLE.isTagged(type) && event.getAction().isLeftClick()) {
-            event.setCancelled(true);
-            toggleDripLeaf(block, player);
         } else if (block.getBlockData() instanceof Directional directional) {
             event.setCancelled(true);
             rotateDirectionalBlock(block, directional, player);
@@ -83,7 +90,7 @@ public class RotateBlockEvent implements Listener {
     }
 
     private void toggleDripLeaf(Block block, Player player) {
-        if (!(block instanceof BigDripleaf bigDripleaf)) {
+        if (!(block.getBlockData() instanceof BigDripleaf bigDripleaf)) {
             return;
         }
 
@@ -94,10 +101,8 @@ public class RotateBlockEvent implements Listener {
         BigDripleaf.Tilt[] values = BigDripleaf.Tilt.values();
 
         int ordinal = bigDripleaf.getTilt().ordinal();
-        if (ordinal == values.length) {
+        if (++ordinal == values.length) {
             ordinal = 0;
-        } else {
-            ordinal++;
         }
 
         bigDripleaf.setTilt(values[ordinal]);
@@ -105,7 +110,7 @@ public class RotateBlockEvent implements Listener {
     }
 
     private void toggleTrapDoor(Block block, Player player) {
-        if (!(block instanceof TrapDoor trapDoor)) {
+        if (!(block.getBlockData() instanceof TrapDoor trapDoor)) {
             return;
         }
 
@@ -114,6 +119,7 @@ public class RotateBlockEvent implements Listener {
         }
 
         trapDoor.setOpen(!trapDoor.isOpen());
+        block.setBlockAndForget(trapDoor);
     }
 
     private void toggleRails(Block block, Player player) {

src/main/java/com/alttd/playerutils/event_listeners/TeleportEvent.java

@@ -18,6 +18,8 @@ public class TeleportEvent implements Listener {
         Player player = event.getPlayer();
         if (player.getVehicle() == null)
             return;
+        if (event.getTo().distance(event.getFrom()) < 5)
+            return;
         event.setCancelled(true);
         player.sendRichMessage("<red>Teleporting was cancelled. You can not be sitting, or mounted while teleporting.");
     }

src/main/java/com/alttd/playerutils/event_listeners/XpBottleEvent.java

@@ -103,7 +103,7 @@ public class XpBottleEvent implements Listener {
         NamespacedKey customXp = NamespacedKey.fromString("custom_xp", playerUtils);
 
         if (customXp == null) {
-            player.sendMiniMessage(Messages.XP_CHEQUE.FAILED_STORAGE, null);
+            player.sendRichMessage(Messages.XP_CHEQUE.FAILED_STORAGE);
             return Optional.empty();
         }
         persistentDataContainer.set(customXp, PersistentDataType.INTEGER, xpValue);