fix: prevent entities from passing through locked portals

gradle.properties

@@ -1,4 +1,4 @@
 kotlin.code.style=official
 kotlin.stdlib.default.dependency=false
 org.gradle.parallel=true
-version=1.21.11-2.0.15-SNAPSHOT
+version=1.21.11-2.0.16-SNAPSHOT

src/main/kotlin/dev/slne/surf/essentials/PaperListenerManager.kt

@@ -12,5 +12,6 @@ object PaperListenerManager {
         UnknownCommandListener.register()
         WorldListener.register()
         SpecialItemListener.register()
+        HungerListener.register()
     }
 }

src/main/kotlin/dev/slne/surf/essentials/listener/CanvasListener.kt

@@ -17,27 +17,33 @@ import org.bukkit.event.player.PlayerTeleportEvent
 object CanvasListener : Listener {
     @EventHandler
     fun onPortal(event: EntityPortalAsyncEvent) {
-        val player = event.entity as? Player ?: return
         val world = event.to
 
-        if (worldService.isLocked(world)) {
-            if (!player.hasPermission(EssentialsPermissionRegistry.WORLD_BYPASS)) {
-                event.cancel()
-                player.sendText {
-                    appendErrorPrefix()
-
-                    when (world.environment) {
-                        World.Environment.NETHER -> error("Der Nether ist zurzeit deaktiviert.")
-                        World.Environment.THE_END -> error("Das End ist zurzeit deaktiviert.")
-                        else -> error("Du kannst dieses Portal nicht benutzen!")
-                    }
-                }
-            } else {
-                player.sendText {
-                    appendSuccessPrefix()
-                    success("Du hast die Portal-Sperre umgangen.")
+        if (!worldService.isLocked(world)) {
+            return
+        }
+
+        val player = event.entity as? Player ?: run {
+            event.cancel()
+            return
+        }
+
+        if (!player.hasPermission(EssentialsPermissionRegistry.WORLD_BYPASS)) {
+            event.cancel()
+            player.sendText {
+                appendErrorPrefix()
+
+                when (world.environment) {
+                    World.Environment.NETHER -> error("Der Nether ist zurzeit deaktiviert.")
+                    World.Environment.THE_END -> error("Das End ist zurzeit deaktiviert.")
+                    else -> error("Du kannst dieses Portal nicht benutzen!")
                 }
             }
+        } else {
+            player.sendText {
+                appendSuccessPrefix()
+                success("Du hast die Portal-Sperre umgangen.")
+            }
         }
     }
 

src/main/kotlin/dev/slne/surf/essentials/listener/HungerListener.kt

@@ -0,0 +1,17 @@
+package dev.slne.surf.essentials.listener
+
+import org.bukkit.entity.Player
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.entity.FoodLevelChangeEvent
+
+object HungerListener : Listener {
+    @EventHandler
+    fun onHungerLose(event: FoodLevelChangeEvent) {
+        val player = event.entity as? Player ?: return
+
+        if (player.isInvulnerable) {
+            event.isCancelled = true
+        }
+    }
+}

src/main/kotlin/dev/slne/surf/essentials/listener/WorldListener.kt

@@ -5,34 +5,41 @@ import dev.slne.surf.essentials.util.permission.EssentialsPermissionRegistry
 import dev.slne.surf.surfapi.bukkit.api.event.cancel
 import dev.slne.surf.surfapi.core.api.messages.adventure.sendText
 import org.bukkit.World
+import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
-import org.bukkit.event.player.PlayerPortalEvent
+import org.bukkit.event.entity.EntityPortalEvent
 
 object WorldListener : Listener {
     @EventHandler
-    fun onPortal(event: PlayerPortalEvent) {
-        val player = event.player
-        val world = event.to.world
+    fun onPortal(event: EntityPortalEvent) {
+        val world = event.to?.world ?: return
 
-        if (worldService.isLocked(world)) {
-            if (!player.hasPermission(EssentialsPermissionRegistry.WORLD_BYPASS)) {
-                event.cancel()
-                player.sendText {
-                    appendErrorPrefix()
+        if (!worldService.isLocked(world)) {
+            return
+        }
 
-                    when (world.environment) {
-                        World.Environment.NETHER -> error("Der Nether ist zurzeit deaktiviert.")
-                        World.Environment.THE_END -> error("Das End ist zurzeit deaktiviert.")
-                        else -> error("Du kannst dieses Portal nicht benutzen!")
-                    }
-                }
-            } else {
-                player.sendText {
-                    appendSuccessPrefix()
-                    success("Du hast die Portal-Sperre umgangen.")
+        val player = event.entity as? Player ?: run {
+            event.cancel()
+            return
+        }
+
+        if (!player.hasPermission(EssentialsPermissionRegistry.WORLD_BYPASS)) {
+            event.cancel()
+            player.sendText {
+                appendErrorPrefix()
+
+                when (world.environment) {
+                    World.Environment.NETHER -> error("Der Nether ist zurzeit deaktiviert.")
+                    World.Environment.THE_END -> error("Das End ist zurzeit deaktiviert.")
+                    else -> error("Du kannst dieses Portal nicht benutzen!")
                 }
             }
+        } else {
+            player.sendText {
+                appendSuccessPrefix()
+                success("Du hast die Portal-Sperre umgangen.")
+            }
         }
     }
 }