Experiment: Add missing teleportation apis for folia

Feature: Add Regionbar

luminol-api/paper-patches/features/0009-Add-missing-teleportation-apis-for-folia.patch

@@ -0,0 +1,348 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Fri, 31 Jan 2025 20:28:47 +0800
+Subject: [PATCH] Add missing teleportation apis for folia
+
+
+diff --git a/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java b/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0c218c99073e4d20532f81c5ab467fbf3e7a57e8
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java
+@@ -0,0 +1,75 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerTeleportEvent;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event fired when a teleportAsync was called
++ * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause)
++ * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location)
++ * (Also fired when teleportAsync called from nms)
++ */
++public class EntityTeleportAsyncEvent extends Event implements Cancellable {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private boolean cancelled = false;
++
++    private final Entity entity;
++    private final PlayerTeleportEvent.TeleportCause teleportCause;
++    private final Location destination;
++
++    public EntityTeleportAsyncEvent(Entity entity, PlayerTeleportEvent.TeleportCause teleportCause, Location destination) {
++        Validate.notNull(entity, "entity cannot be a null value!");
++        Validate.notNull(teleportCause, "teleportCause cannot be a null value!");
++        Validate.notNull(destination, "destination cannot be a null value!");
++
++        this.entity = entity;
++        this.teleportCause = teleportCause;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the entity is about to be teleported
++     * @return that entity
++     */
++    public @NotNull Entity getEntity() {
++        return this.entity;
++    }
++
++    /**
++     * Get the cause of the teleport
++     * @return the cause
++     */
++    public @NotNull PlayerTeleportEvent.TeleportCause getTeleportCause() {
++        return this.teleportCause;
++    }
++
++    /**
++     * Get the destination of the teleport
++     * @return the destination
++     */
++    public @NotNull Location getDestination() {
++        return this.destination;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java b/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..50b601d124bbaf4eedb626d84ed6dae9ab6e9ef1
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java
+@@ -0,0 +1,36 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event created for missing teleport events api of folia
++ * This event is fired when the entity portal process has been done
++ */
++public class PostEntityPortalEvent extends Event {
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Entity teleportedEntity;
++
++    public PostEntityPortalEvent(Entity teleportedEntity) {
++        Validate.notNull(teleportedEntity, "teleportedEntity cannot be null!");
++
++        this.teleportedEntity = teleportedEntity;
++    }
++
++    /**
++     * Get the entity which was teleported
++     * @return the entity which was teleported
++     */
++    public Entity getTeleportedEntity() {
++        return this.teleportedEntity;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java b/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e25146f3b5d296ecd21e62ed97f574f6a3a4af1d
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java
+@@ -0,0 +1,73 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.World;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event created for missing teleport events api of folia
++ * This event will be fired when a portal teleportation is about to happen
++ */
++public class PreEntityPortalEvent extends Event implements Cancellable {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Entity entity;
++    private final Location portalPos;
++    private final World destination;
++
++    private boolean cancelled = false;
++
++    public PreEntityPortalEvent(Entity entity, Location portalPos, World destination) {
++        Validate.notNull(entity, "entity cannot be null!");
++        Validate.notNull(portalPos, "portalPos cannot be null!");
++        Validate.notNull(destination, "destination cannot be null!");
++
++        this.entity = entity;
++        this.portalPos = portalPos;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the entity that is about to teleport
++     * @return the entity
++     */
++    public @NotNull Entity getEntity() {
++        return this.entity;
++    }
++
++    /**
++     * Get the location of the portal
++     * @return the portal location
++     */
++    public @NotNull Location getPortalPos() {
++        return this.portalPos;
++    }
++
++    /**
++     * Get the destination world
++     * @return the destination world
++     */
++    public @NotNull World getDestination() {
++        return this.destination;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java b/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..bf4469593b22f3e5cff89953819e7fdde252abf5
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java
+@@ -0,0 +1,35 @@
++package me.earthme.luminol.api.entity.player;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event fired when the respawn process of player is done
++ */
++public class PostPlayerRespawnEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Player player;
++
++    public PostPlayerRespawnEvent(Player player) {
++        Validate.notNull(player, "Player cannot be a null value!");
++
++        this.player = player;
++    }
++
++    /**
++     * Get the respawned player
++     * @return the player
++     */
++    public @NotNull Player getPlayer() {
++        return this.player;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java b/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..12b2bef2f66f22bb56c10434cc08b39cef335447
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java
+@@ -0,0 +1,30 @@
++package me.earthme.luminol.api.portal;
++
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A event fired when an end platform is created.
++ */
++public class EndPlatformCreateEvent extends Event implements Cancellable {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private boolean cancelled = false;
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java b/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f68bf95bba671f3cf90d9878d93dd319bdf9db40
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java
+@@ -0,0 +1,57 @@
++package me.earthme.luminol.api.portal;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A event fired when the portal process started locating the destination position
++ */
++public class PortalLocateEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Location original;
++    private Location destination;
++
++    public PortalLocateEvent(Location original, Location destination) {
++        Validate.notNull(original, "original couldn't be null!");
++        Validate.notNull(destination, "destination couldn't be null!");
++
++        this.original = original;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the destination position of this teleportation
++     * @return the destination position
++     */
++    public Location getDestination() {
++        return this.destination;
++    }
++
++    /**
++     * Set the destination position of this teleportation
++     * @param destination the destination position
++     */
++    public void setDestination(@NotNull Location destination) {
++        Validate.notNull(destination, "Destination position couldn't be null!");
++        Validate.isTrue(destination.getWorld().equals(this.destination.getWorld()), "Destination position couldn't be a different level!");
++
++        this.destination = destination;
++    }
++
++    /**
++     * Get the original portal position of this teleportation
++     * @return the original portal position
++     */
++    public Location getOriginal() {
++        return this.original;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++}

luminol-server/minecraft-patches/features/0007-Add-a-simple-regionbar.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: adabugra <57899270+adabugra@users.noreply.github.com>
+Date: Fri, 31 Jan 2025 01:21:44 +0300
+Subject: [PATCH] Add a simple regionbar
+
+
+diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
+index cc80198a5d5f4e9188ef35944d077200f03ac43b..c6490516215ad94323174de81771f258cecc7742 100644
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -766,6 +766,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+     public void stopServer() {
+         me.earthme.luminol.functions.GlobalServerTpsBar.cancelBarUpdateTask(); //Luminol - Tpsbar
+         me.earthme.luminol.functions.GlobalServerMemoryBar.cancelBarUpdateTask(); //Luminol - Memory bar
++        me.earthme.luminol.functions.GlobalServerRegionBar.cancelBarUpdateTask(); //Luminol - Region bar
+         super.stopServer();
+         //Util.shutdownExecutors(); // Paper - Improved watchdog support; moved into super
+         SkullBlockEntity.clear();
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index a07e02132bdda2693686440b9932992641cb6957..f1239f1a7b6b8fd958333df8092359eea7197fc0 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -395,6 +395,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
+     public volatile boolean isTpsBarVisible = false; //Luminol - Tps bar
+     public volatile boolean isMemBarVisible = false; //Luminol - Memory bar
++    public volatile boolean isRegionBarVisible = false; //Luminol - Region bar
+     // Paper start - rewrite chunk system
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+     private final ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder viewDistanceHolder = new ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder();

luminol-server/minecraft-patches/features/0009-Add-config-for-offline-mode-warning.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Add config for offline mode warning
 
 
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index cc80198a5d5f4e9188ef35944d077200f03ac43b..82f80e152a8b7426d711df7df6eae9043cf35e69 100644
+index c6490516215ad94323174de81771f258cecc7742..ff2de692d397bf658fc7c8af0c6ce7697d1076a7 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -285,7 +285,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface

luminol-server/minecraft-patches/features/0012-Add-config-to-disable-entity-tick-catchers.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Add config to disable entity tick catchers
 
 
 diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
-index 5ea7fdf1e337da4c207dd6a53ca942480dd31922..926f5c91eb59277704618fe1910f3dbb38cff002 100644
+index dafd90502937019b616ac0a79465e1dbc578cf66..96daa716aa06de31b2867f09833ac8e77b6314c4 100644
 --- a/net/minecraft/world/level/Level.java
 +++ b/net/minecraft/world/level/Level.java
 @@ -1547,6 +1547,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl

luminol-server/minecraft-patches/features/0019-Force-disable-builtin-spark-plugin.patch

@@ -75,7 +75,7 @@ index c00378ba258647787bb9138e319b0f6a0b00e1ed..ff71466ec0848d16121e351e30c31bb4
      }
  
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index 82f80e152a8b7426d711df7df6eae9043cf35e69..298d9eb8e303fb4eaae58dcc5c9f29e23150496f 100644
+index ff2de692d397bf658fc7c8af0c6ce7697d1076a7..5973e6f327d3557ca95f504fe7b1a6c227a3e15f 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -214,7 +214,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface

luminol-server/minecraft-patches/features/0020-Merge-Paper-11945-for-temporary-hopper-behavior-fix.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <wangxyper@163.com>
 Date: Sun, 12 Jan 2025 11:03:09 +0800
-Subject: [PATCH] Merge Paper #11945 for temporary hooper behavior fix
+Subject: [PATCH] Merge Paper #11945 for temporary hopper behavior fix
 
 A hopper optimization fix on Paper's pr : https://github.com/PaperMC/Paper/pull/11945
 

luminol-server/minecraft-patches/features/0022-Merge-paper-12047.patch

@@ -0,0 +1,87 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Fri, 31 Jan 2025 12:54:45 +0800
+Subject: [PATCH] Merge paper #12047
+
+
+diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
+index ba8b5a0ebe652bfaf5c1498c19d12a91a192bf8e..8b661a11ed798186335b4ea6b907eb719cbbf722 100644
+--- a/io/papermc/paper/entity/activation/ActivationRange.java
++++ b/io/papermc/paper/entity/activation/ActivationRange.java
+@@ -40,10 +40,10 @@ public final class ActivationRange {
+     }
+ 
+     static Activity[] VILLAGER_PANIC_IMMUNITIES = {
+-        Activity.HIDE,
+-        Activity.PRE_RAID,
+-        Activity.RAID,
+-        Activity.PANIC
++            Activity.HIDE,
++            Activity.PRE_RAID,
++            Activity.RAID,
++            Activity.PANIC
+     };
+ 
+     private static int checkInactiveWakeup(final Entity entity) {
+@@ -85,28 +85,28 @@ public final class ActivationRange {
+      * @return boolean If it should always tick.
+      */
+     public static boolean initializeEntityActivationState(final Entity entity, final SpigotWorldConfig config) {
+-        return (entity.activationType == ActivationType.MISC && config.miscActivationRange == 0)
+-            || (entity.activationType == ActivationType.RAIDER && config.raiderActivationRange == 0)
+-            || (entity.activationType == ActivationType.ANIMAL && config.animalActivationRange == 0)
+-            || (entity.activationType == ActivationType.MONSTER && config.monsterActivationRange == 0)
+-            || (entity.activationType == ActivationType.VILLAGER && config.villagerActivationRange <= 0)
+-            || (entity.activationType == ActivationType.WATER && config.waterActivationRange <= 0)
+-            || (entity.activationType == ActivationType.FLYING_MONSTER && config.flyingMonsterActivationRange <= 0)
+-            || entity instanceof EyeOfEnder
+-            || entity instanceof Player
+-            || entity instanceof ThrowableProjectile
+-            || entity instanceof EnderDragon
+-            || entity instanceof EnderDragonPart
+-            || entity instanceof WitherBoss
+-            || entity instanceof AbstractHurtingProjectile
+-            || entity instanceof LightningBolt
+-            || entity instanceof PrimedTnt
+-            || entity instanceof net.minecraft.world.entity.item.FallingBlockEntity
+-            || entity instanceof net.minecraft.world.entity.vehicle.AbstractMinecart
+-            || entity instanceof net.minecraft.world.entity.vehicle.AbstractBoat
+-            || entity instanceof EndCrystal
+-            || entity instanceof FireworkRocketEntity
+-            || entity instanceof ThrownTrident;
++        return (entity.activationType == ActivationType.MISC && config.miscActivationRange <= 0) // Luminol - Merge paper #12047
++                || (entity.activationType == ActivationType.RAIDER && config.raiderActivationRange <= 0) // Luminol - Merge paper #12047
++                || (entity.activationType == ActivationType.ANIMAL && config.animalActivationRange <= 0) // Luminol - Merge paper #12047
++                || (entity.activationType == ActivationType.MONSTER && config.monsterActivationRange <= 0) // Luminol - Merge paper #12047
++                || (entity.activationType == ActivationType.VILLAGER && config.villagerActivationRange <= 0)
++                || (entity.activationType == ActivationType.WATER && config.waterActivationRange <= 0)
++                || (entity.activationType == ActivationType.FLYING_MONSTER && config.flyingMonsterActivationRange <= 0)
++                || entity instanceof EyeOfEnder
++                || entity instanceof Player
++                || entity instanceof ThrowableProjectile
++                || entity instanceof EnderDragon
++                || entity instanceof EnderDragonPart
++                || entity instanceof WitherBoss
++                || entity instanceof AbstractHurtingProjectile
++                || entity instanceof LightningBolt
++                || entity instanceof PrimedTnt
++                || entity instanceof net.minecraft.world.entity.item.FallingBlockEntity
++                || entity instanceof net.minecraft.world.entity.vehicle.AbstractMinecart
++                || entity instanceof net.minecraft.world.entity.vehicle.AbstractBoat
++                || entity instanceof EndCrystal
++                || entity instanceof FireworkRocketEntity
++                || entity instanceof ThrownTrident;
+     }
+ 
+     /**
+@@ -234,8 +234,8 @@ public final class ActivationRange {
+             if (entity instanceof final Bee bee) {
+                 final BlockPos movingTarget = bee.getMovingTarget();
+                 if (bee.isAngry() ||
+-                    (bee.getHivePos() != null && bee.getHivePos().equals(movingTarget)) ||
+-                    (bee.getSavedFlowerPos() != null && bee.getSavedFlowerPos().equals(movingTarget))
++                        (bee.getHivePos() != null && bee.getHivePos().equals(movingTarget)) ||
++                        (bee.getSavedFlowerPos() != null && bee.getSavedFlowerPos().equals(movingTarget))
+                 ) {
+                     return 20;
+                 }

luminol-server/minecraft-patches/features/0026-KioCG-Chunk-API-and-display-of-chunkhot-in-tpsbar.patch

@@ -104,10 +104,10 @@ index ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8..887a12b0b33a24f77e3dc118688f9e5b
      }
  
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index a07e02132bdda2693686440b9932992641cb6957..cbe7f275e7a466bd7f8ea184b22ced908b5a3d20 100644
+index f1239f1a7b6b8fd958333df8092359eea7197fc0..9fd3fe181df2ce6dbe695f6463d3940ac4c01167 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -1007,7 +1007,34 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -1008,7 +1008,34 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
          this.trackEnteredOrExitedLavaOnVehicle();
          this.updatePlayerAttributes();
          this.advancements.flushDirty(this);

luminol-server/minecraft-patches/features/0030-Pufferfish-Cache-climbing-check-for-activation.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Pufferfish Cache climbing check for activation
 
 
 diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
-index ba8b5a0ebe652bfaf5c1498c19d12a91a192bf8e..76e0b50b2dc9c718a67f89de720a891b398cec2a 100644
+index 8b661a11ed798186335b4ea6b907eb719cbbf722..956807b34d5fda666966d23d46a7ae4ec5055071 100644
 --- a/io/papermc/paper/entity/activation/ActivationRange.java
 +++ b/io/papermc/paper/entity/activation/ActivationRange.java
 @@ -225,7 +225,7 @@ public final class ActivationRange {

luminol-server/minecraft-patches/features/0033-Gale-Variable-entity-wake-up-duration.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Gale Variable entity wake-up duration
 
 
 diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
-index 76e0b50b2dc9c718a67f89de720a891b398cec2a..e3d2371e36b48bb820931394e5b4182152f57630 100644
+index 956807b34d5fda666966d23d46a7ae4ec5055071..3a1c4f9f44026dcff7f4a32bb3ceaf79963389ed 100644
 --- a/io/papermc/paper/entity/activation/ActivationRange.java
 +++ b/io/papermc/paper/entity/activation/ActivationRange.java
 @@ -54,27 +54,39 @@ public final class ActivationRange {

luminol-server/minecraft-patches/features/0041-Add-missing-teleportation-apis-for-folia.patch

@@ -0,0 +1,136 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Fri, 31 Jan 2025 20:28:45 +0800
+Subject: [PATCH] Add missing teleportation apis for folia
+
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index 9fd3fe181df2ce6dbe695f6463d3940ac4c01167..822d401150d3764004b2570da828b4f69f19dcec 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -1653,6 +1653,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+                     if (respawnComplete != null) {
+                         respawnComplete.accept(ServerPlayer.this);
+                     }
++                    // Luminol - Add missing teleportation apis
++                    new me.earthme.luminol.api.entity.player.PostPlayerRespawnEvent(ServerPlayer.this.getBukkitEntity()).callEvent();
++                    // Luminol end
+                 }
+             );
+         });
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 406c382ae2fdaa7d8996d250487bbdfb7e4bb7f9..29fc2e5af0b6ec81c3f0c1c89f76166e7f4ac19c 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -4164,6 +4164,15 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         }
+ 
+         // TODO any events that can modify go HERE
++        // Luminol start - Add missing teleportation apis
++        if (!new me.earthme.luminol.api.entity.EntityTeleportAsyncEvent(
++                this.getBukkitEntity(),
++                cause,
++                io.papermc.paper.util.MCUtil.toLocation(destination, pos, yaw ,pitch)
++        ).callEvent()) {
++            return false;
++        }
++        // Luminol end
+ 
+         // check for same region
+         if (destination == this.level()) {
+@@ -4280,7 +4289,20 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             // we just select the spawn position
+             case END: {
+                 if (destination.getTypeKey() == net.minecraft.world.level.dimension.LevelStem.END) {
+-                    BlockPos targetPos = ServerLevel.END_SPAWN_POINT;
++                    BlockPos targetPos1 = ServerLevel.END_SPAWN_POINT; // Luminol - Rename
++                    // Luminol start - Add missing teleportation apis
++                    final org.bukkit.Location orginalPortalLocation = io.papermc.paper.util.MCUtil.toLocation(origin, originPortal);
++                    final org.bukkit.Location targetPortalLocation = io.papermc.paper.util.MCUtil.toLocation(destination, targetPos1);
++
++                    final me.earthme.luminol.api.portal.PortalLocateEvent portalLocateEvent = new me.earthme.luminol.api.portal.PortalLocateEvent(
++                            orginalPortalLocation,
++                            targetPortalLocation
++                    );
++
++                    portalLocateEvent.callEvent();
++
++                    final BlockPos targetPos = io.papermc.paper.util.MCUtil.toBlockPosition(portalLocateEvent.getDestination()); // Swap value
++                    // Luminol end
+                     // need to load chunks so we can create the platform
+                     destination.moonrise$loadChunksAsync(
+                         targetPos, 16, // load 16 blocks to be safe from block physics
+@@ -4305,7 +4327,20 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         }
+                     );
+                 } else {
+-                    BlockPos spawnPos = destination.getSharedSpawnPos();
++                    BlockPos spawnPos1 = destination.getSharedSpawnPos(); // Luminol - Rename
++                    // Luminol start - Add missing teleportation apis
++                    final org.bukkit.Location orginalPortalLocation = io.papermc.paper.util.MCUtil.toLocation(origin, originPortal);
++                    final org.bukkit.Location targetPortalLocation = io.papermc.paper.util.MCUtil.toLocation(destination, spawnPos1);
++
++                    final me.earthme.luminol.api.portal.PortalLocateEvent portalLocateEvent = new me.earthme.luminol.api.portal.PortalLocateEvent(
++                            orginalPortalLocation,
++                            targetPortalLocation
++                    );
++
++                    portalLocateEvent.callEvent();
++
++                    final BlockPos spawnPos = io.papermc.paper.util.MCUtil.toBlockPosition(portalLocateEvent.getDestination()); // Swap value
++                    // Luminol end
+                     // need to load chunk for heightmap
+                     destination.moonrise$loadChunksAsync(
+                         spawnPos, 0,
+@@ -4355,8 +4390,20 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+ 
+                 WorldBorder destinationBorder = destination.getWorldBorder();
+                 double dimensionScale = net.minecraft.world.level.dimension.DimensionType.getTeleportationScale(origin.dimensionType(), destination.dimensionType());
+-                BlockPos targetPos = destination.getWorldBorder().clampToBounds(this.getX() * dimensionScale, this.getY(), this.getZ() * dimensionScale);
++                BlockPos targetPos1 = destination.getWorldBorder().clampToBounds(this.getX() * dimensionScale, this.getY(), this.getZ() * dimensionScale); // Luminol - Rename
++                // Luminol start - Add missing teleportation apis
++                final org.bukkit.Location orginalPortalLocation = io.papermc.paper.util.MCUtil.toLocation(origin, originPortal);
++                final org.bukkit.Location targetPortalLocation = io.papermc.paper.util.MCUtil.toLocation(destination, targetPos1);
++
++                final me.earthme.luminol.api.portal.PortalLocateEvent portalLocateEvent = new me.earthme.luminol.api.portal.PortalLocateEvent(
++                        orginalPortalLocation,
++                        targetPortalLocation
++                );
++
++                portalLocateEvent.callEvent();
+ 
++                final BlockPos targetPos = io.papermc.paper.util.MCUtil.toBlockPosition(portalLocateEvent.getDestination()); // Swap value
++                // Luminol end
+                 ca.spottedleaf.concurrentutil.completable.CallbackCompletable<BlockUtil.FoundRectangle> portalFound
+                     = new ca.spottedleaf.concurrentutil.completable.CallbackCompletable<>();
+ 
+@@ -4493,9 +4540,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         if (!this.canPortalAsync(destination, takePassengers)) {
+             return false;
+         }
++        // Luminol start - Add missing teleportation events
++        if (!new me.earthme.luminol.api.entity.PreEntityPortalEvent(
++                this.getBukkitEntity(),
++                io.papermc.paper.util.MCUtil.toLocation(this.level, portalPos),
++                destination.getWorld()
++        ).callEvent()) {
++            return false;
++        }
++        // Luminol end
+         // Kaiiju start - sync end platform spawning & entity teleportation
+         final java.util.function.Consumer<Entity> tpComplete = type == PortalType.END && destination.getTypeKey() == LevelStem.END ?
+-              e -> net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null) : teleportComplete;
++              e -> { if (new me.earthme.luminol.api.portal.EndPlatformCreateEvent().callEvent()) net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null); } : teleportComplete; // Luminol - Add missing teleportation events
+         // Kaiiju end
+ 
+         Vec3 initialPosition = this.position();
+@@ -4569,6 +4625,9 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         tpComplete.accept(teleported);
+                     }
+                     // Kaiiju end
++                    // Luminol start - Add missing teleportation events
++                    new me.earthme.luminol.api.entity.PostEntityPortalEvent(teleported.getBukkitEntity()).callEvent();
++                    // Luminol end
+                 }
+             );
+         });

luminol-server/paper-patches/features/0008-Add-a-simple-regionbar.patch

@@ -0,0 +1,330 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: adabugra <57899270+adabugra@users.noreply.github.com>
+Date: Fri, 31 Jan 2025 01:21:44 +0300
+Subject: [PATCH] Add a simple regionbar
+
+
+diff --git a/src/main/java/me/earthme/luminol/commands/RegionBarCommand.java b/src/main/java/me/earthme/luminol/commands/RegionBarCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..68618b0364b7da6018888b06db165591da951e57
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/commands/RegionBarCommand.java
+@@ -0,0 +1,47 @@
++package me.earthme.luminol.commands;
++
++import me.earthme.luminol.config.modules.misc.RegionBarConfig;
++import me.earthme.luminol.functions.GlobalServerRegionBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.TextColor;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++
++public class RegionBarCommand extends Command {
++    public RegionBarCommand(@NotNull String name) {
++        super(name);
++        this.setPermission("luminol.commands.regionbar");
++        this.setDescription("Show info about your current region through a bossbar");
++        this.setUsage("/regionbar");
++    }
++
++    @Override
++    public boolean execute(@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] args) {
++        if (!testPermission(sender)) {
++            return true;
++        }
++
++        if (!RegionBarConfig.regionbarEnabled) {
++            sender.sendMessage(Component.text("Regionbar was already disabled!").color(TextColor.color(255, 0, 0)));
++            return true;
++        }
++
++        if (!(sender instanceof Player player)) {
++            sender.sendMessage(Component.text("Only player can use this command!").color(TextColor.color(255, 0, 0)));
++            return true;
++        }
++
++        if (GlobalServerRegionBar.isPlayerVisible(player)) {
++            player.sendMessage(Component.text("Disabled region bar").color(TextColor.color(0, 255, 0)));
++            GlobalServerRegionBar.setVisibilityForPlayer(player, false);
++            return true;
++        }
++
++        player.sendMessage(Component.text("Enabled region bar").color(TextColor.color(0, 255, 0)));
++        GlobalServerRegionBar.setVisibilityForPlayer(player, true);
++
++        return true;
++    }
++}
+\ No newline at end of file
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/RegionBarConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/RegionBarConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..34ebfe9e22623985bdc33c3f475f709b030c50e9
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/RegionBarConfig.java
+@@ -0,0 +1,50 @@
++package me.earthme.luminol.config.modules.misc;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import me.earthme.luminol.commands.RegionBarCommand;
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.DoNotLoad;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++import me.earthme.luminol.functions.GlobalServerRegionBar;
++import org.bukkit.Bukkit;
++
++import java.util.List;
++
++public class RegionBarConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean regionbarEnabled = false;
++    @ConfigInfo(baseName = "format")
++    public static String regionBarFormat = "<gray>Util<yellow>:</yellow> <util> Chunks<yellow>:</yellow> <green><chunks></green> Players<yellow>:</yellow> <green><players></green> Entities<yellow>:</yellow> <green><entities></green>";
++    @ConfigInfo(baseName = "util_color_list")
++    public static List<String> utilColors = List.of("GREEN", "YELLOW", "RED", "PURPLE");
++    @ConfigInfo(baseName = "update_interval_ticks")
++    public static int updateInterval = 15;
++
++    @DoNotLoad
++    private static boolean inited = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "regionbar";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig configInstance) {
++        if (regionbarEnabled) {
++            GlobalServerRegionBar.init();
++        } else {
++            GlobalServerRegionBar.cancelBarUpdateTask();
++        }
++
++        if (!inited) {
++            Bukkit.getCommandMap().register("regionbar", "luminol", new RegionBarCommand("regionbar"));
++            inited = true;
++        }
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/functions/GlobalServerRegionBar.java b/src/main/java/me/earthme/luminol/functions/GlobalServerRegionBar.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ef9d69e73fbd1fea7d04e9df9d11dfd694836077
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/functions/GlobalServerRegionBar.java
+@@ -0,0 +1,184 @@
++package me.earthme.luminol.functions;
++
++import com.google.common.collect.Maps;
++import com.mojang.logging.LogUtils;
++import io.papermc.paper.threadedregions.*;
++import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
++import me.earthme.luminol.config.modules.misc.RegionBarConfig;
++import me.earthme.luminol.utils.NullPlugin;
++import net.kyori.adventure.bossbar.BossBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.minimessage.MiniMessage;
++import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++import org.slf4j.Logger;
++
++import java.text.DecimalFormat;
++import java.util.*;
++
++public class GlobalServerRegionBar {
++    protected static final NullPlugin NULL_PLUGIN = new NullPlugin();
++    protected static final Map<UUID, BossBar> uuid2Bossbars = Maps.newConcurrentMap();
++    protected static final Map<UUID, ScheduledTask> scheduledTasks = new HashMap<>();
++
++    protected static volatile ScheduledTask scannerTask = null;
++    private static final Logger logger = LogUtils.getLogger();
++
++    private static final ThreadLocal<DecimalFormat> ONE_DECIMAL_PLACES = ThreadLocal.withInitial(() -> new DecimalFormat("#,##0.0"));
++
++    public static void init() {
++        cancelBarUpdateTask();
++
++        scannerTask = Bukkit.getGlobalRegionScheduler().runAtFixedRate(NULL_PLUGIN, unused -> {
++            try {
++                update();
++                cleanUp();
++            } catch (Exception e) {
++                logger.error(e.getLocalizedMessage());
++            }
++        }, 1, RegionBarConfig.updateInterval);
++    }
++
++    public static void cancelBarUpdateTask() {
++        if (scannerTask == null || scannerTask.isCancelled()) {
++            return;
++        }
++
++        scannerTask.cancel();
++
++        for (ScheduledTask task : scheduledTasks.values()) {
++            if (!task.isCancelled()) {
++                task.cancel();
++            }
++        }
++    }
++
++    public static boolean isPlayerVisible(Player player) {
++        return ((CraftPlayer) player).getHandle().isRegionBarVisible;
++    }
++
++    public static void setVisibilityForPlayer(Player target, boolean canSee) {
++        ((CraftPlayer) target).getHandle().isRegionBarVisible = canSee;
++    }
++
++    private static void update() {
++        for (Player player : Bukkit.getOnlinePlayers()) {
++            scheduledTasks.computeIfAbsent(player.getUniqueId(), unused -> createBossBarForPlayer(player));
++        }
++    }
++
++    private static void cleanUp() {
++        final List<UUID> toCleanUp = new ArrayList<>();
++
++        for (Map.Entry<UUID, ScheduledTask> toCheck : scheduledTasks.entrySet()) {
++            if (toCheck.getValue().isCancelled()) {
++                toCleanUp.add(toCheck.getKey());
++            }
++        }
++
++        for (UUID uuid : toCleanUp) {
++            scheduledTasks.remove(uuid);
++        }
++    }
++
++    public static ScheduledTask createBossBarForPlayer(@NotNull Player apiPlayer) {
++        final UUID playerUUID = apiPlayer.getUniqueId();
++
++        return apiPlayer.getScheduler().runAtFixedRate(NULL_PLUGIN, (n) -> {
++            if (!isPlayerVisible(apiPlayer)) {
++                final BossBar removed = uuid2Bossbars.remove(playerUUID);
++
++                if (removed != null) {
++                    apiPlayer.hideBossBar(removed);
++                }
++                return;
++            }
++
++            final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region = TickRegionScheduler.getCurrentRegion();
++            final TickData.TickReportData reportData = region.getData().getRegionSchedulingHandle().getTickReport5s(System.nanoTime());
++            final TickRegions.RegionStats regionStats = region.getData().getRegionStats();
++
++            BossBar targetBossbar = uuid2Bossbars.computeIfAbsent(
++                    playerUUID,
++                    unused -> BossBar.bossBar(Component.text(""), 0.0F, BossBar.Color.GREEN, BossBar.Overlay.NOTCHED_20)
++            );
++
++            apiPlayer.showBossBar(targetBossbar);
++
++            if (reportData != null) {
++                final double utilisation = reportData.utilisation();
++                final int chunkCount = regionStats.getChunkCount();
++                final int playerCount = regionStats.getPlayerCount();
++                final int entityCount = regionStats.getEntityCount();
++
++                updateRegionBar(utilisation, chunkCount, playerCount, entityCount, targetBossbar);
++            }
++        }, () -> {
++            final BossBar removed = uuid2Bossbars.remove(playerUUID); // Auto clean up it
++
++            if (removed != null) {
++                apiPlayer.hideBossBar(removed);
++            }
++        }, 1, RegionBarConfig.updateInterval);
++    }
++
++    private static void updateRegionBar(double utilisation, int chunks, int players, int entities, @NotNull BossBar bar) {
++        final double utilisationPercent = utilisation * 100.0;
++        final String formattedUtil = ONE_DECIMAL_PLACES.get().format(utilisationPercent);
++
++        bar.name(MiniMessage.miniMessage().deserialize(
++                RegionBarConfig.regionBarFormat,
++                Placeholder.component("util", getUtilComponent(formattedUtil)),
++                Placeholder.component("chunks", getChunksComponent(chunks)),
++                Placeholder.component("players", getPlayersComponent(players)),
++                Placeholder.component("entities", getEntitiesComponent(entities))
++        ));
++
++        bar.color(barColorFromUtil(utilisationPercent));
++        bar.progress((float) Math.min(1.0, Math.max(utilisation, 0)));
++    }
++
++    private static @NotNull Component getEntitiesComponent(int entities) {
++        final String content = "<text>";
++        return MiniMessage.miniMessage().deserialize(content, Placeholder.parsed("text", String.valueOf(entities)));
++    }
++
++    private static @NotNull Component getPlayersComponent(int players) {
++        final String content = "<text>";
++        return MiniMessage.miniMessage().deserialize(content, Placeholder.parsed("text", String.valueOf(players)));
++    }
++
++    private static @NotNull Component getChunksComponent(int chunks) {
++        final String content = "<text>";
++        return MiniMessage.miniMessage().deserialize(content, Placeholder.parsed("text", String.valueOf(chunks)));
++    }
++
++    private static @NotNull Component getUtilComponent(String formattedUtil) {
++        final BossBar.Color colorBukkit = barColorFromUtil(Double.parseDouble(formattedUtil));
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content, colorString, colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced, Placeholder.parsed("text", formattedUtil + "%"));
++    }
++
++    private static BossBar.Color barColorFromUtil(double util) {
++        if (util >= 100) {
++            return BossBar.Color.valueOf(RegionBarConfig.utilColors.get(3)); // PURPLE
++        }
++
++        if (util >= 70) {
++            return BossBar.Color.valueOf(RegionBarConfig.utilColors.get(2)); // RED
++        }
++
++        if (util >= 50) {
++            return BossBar.Color.valueOf(RegionBarConfig.utilColors.get(1)); // YELLOW
++        }
++
++        return BossBar.Color.valueOf(RegionBarConfig.utilColors.get(0)); // GREEN
++    }
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 7a112a3a0a9411a166666c657dac6b7888105545..03a9f4d8e83f53326c30f00286efd1ddaaac84d2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2409,6 +2409,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+             //Luminol start - Membar
+             getHandle().isMemBarVisible = data.getBoolean("membarVisible");
+             //Luminol end
++            //Luminol start - Regionbar
++            getHandle().isRegionBarVisible = data.getBoolean("regionbarVisible");
++            //Luminol end
+         }
+     }
+ 
+@@ -2436,6 +2439,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         //Luminol start - Membar
+         data.putBoolean("membarVisible", handle.isMemBarVisible);
+         //Luminol end
++        //Luminol start - Regionbar
++        data.putBoolean("regionbarVisible", handle.isRegionBarVisible);
++        //Luminol end
+         // Paper start - persist for use in offline save data
+         if (!nbttagcompound.contains("Paper")) {
+             nbttagcompound.put("Paper", new CompoundTag());

luminol-server/paper-patches/features/0021-Merge-paper-12047.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Fri, 31 Jan 2025 12:54:46 +0800
+Subject: [PATCH] Merge paper #12047
+
+
+diff --git a/src/main/java/io/papermc/paper/entity/activation/ActivationType.java b/src/main/java/io/papermc/paper/entity/activation/ActivationType.java
+index 01fef8353934f22a5176e731847d3df4a7df5306..f707c982ce1f650eaf8c6501b816bb5717cb0a45 100644
+--- a/src/main/java/io/papermc/paper/entity/activation/ActivationType.java
++++ b/src/main/java/io/papermc/paper/entity/activation/ActivationType.java
+@@ -28,7 +28,7 @@ public enum ActivationType {
+      * @return activation type
+      */
+     public static ActivationType activationTypeFor(final Entity entity) {
+-        if (entity instanceof WaterAnimal) {
++        if (entity instanceof WaterAnimal || entity instanceof net.minecraft.world.entity.animal.AgeableWaterCreature) { // Luminol - Merge paper #12047
+             return ActivationType.WATER;
+         } else if (entity instanceof Villager) {
+             return ActivationType.VILLAGER;
+@@ -44,4 +44,4 @@ public enum ActivationType {
+             return ActivationType.MISC;
+         }
+     }
+-}
++}
+\ No newline at end of file

luminol-server/paper-patches/features/0022-KioCG-Chunk-API-and-display-of-chunkhot-in-tpsbar.patch

@@ -184,10 +184,10 @@ index de8b9048c8395c05b8688bc9d984b8ad680f15b3..f42692cd4f0154705c3d5b030d281cfc
 +    // KioCG end
  }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 7a112a3a0a9411a166666c657dac6b7888105545..8e9190da44839ba62880cf3218b5d5aaf300e34f 100644
+index 03a9f4d8e83f53326c30f00286efd1ddaaac84d2..84304fc8c26a6e1e3515b131a2ee3357262efcc3 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -3605,4 +3605,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -3611,4 +3611,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
          handle.containerMenu.broadcastChanges();
          return new PaperPlayerGiveResult(leftovers.build(), drops.build());
      }

luminol-server/paper-patches/features/0033-SparklyPaper-Optimize-canSee-checks.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] SparklyPaper Optimize canSee checks
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 8e9190da44839ba62880cf3218b5d5aaf300e34f..e411f0e94b983fce88c67e9dadc0f6ded90e973c 100644
+index 84304fc8c26a6e1e3515b131a2ee3357262efcc3..e3fe81a1d91f60c6696070751c5220ec1868390a 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 @@ -213,7 +213,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {