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`.

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

@@ -42,6 +42,7 @@ public final class PlayerUtils extends JavaPlugin {
         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(logger);
         pluginManager.registerEvents(rotateBlockEvent, this);

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

@@ -41,17 +41,17 @@ 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.sendRichMessage(getHelpMessage());
@@ -97,6 +97,7 @@ public class Glow extends SubCommand {
     private void turnOffGlow(CommandSender commandSender, Player player, boolean otherPlayer) {
         player.sendRichMessage(Messages.GLOW.GLOW_OFF);
         player.setGlowing(false);
+
         if (otherPlayer) {
             commandSender.sendRichMessage(Messages.GLOW.GLOW_OFF_FOR_PLAYER, Placeholder.component("player", player.name()));
         }

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/LimitArmorStands.java

@@ -3,10 +3,15 @@ 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;
@@ -35,8 +40,13 @@ public class LimitArmorStands implements Listener {
                 @NotNull PersistentDataContainer persistentDataContainer);
     }
 
+    @FunctionalInterface
+    private interface TrialSpawnerTimerConsumer {
+        void apply(int ticks, @NotNull Player player);
+    }
+
     @EventHandler
-    public void onArmorStandSpawn(PlayerInteractEvent event) {
+    public void onPlayerInteractEvent(PlayerInteractEvent event) {
         handleArmorStandPlacing(event, (armorStandCount, player, namespacedKey, persistentDataContainer) -> {
             int max = 0;
             for (String permission : Config.ARMOR_STAND_LIMIT.LIMIT.keySet()) {
@@ -52,6 +62,16 @@ public class LimitArmorStands implements Listener {
             }
             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) {
@@ -89,6 +109,36 @@ public class LimitArmorStands implements Listener {
         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))