fix: NullPointer Exception

Author: DaRacci

Minix-API/api/Minix-API.api

@@ -1510,6 +1510,7 @@ public final class dev/racci/minix/api/integrations/Integration$DefaultImpls {
 public class dev/racci/minix/api/integrations/IntegrationManager {
 	public static final field Companion Ldev/racci/minix/api/integrations/IntegrationManager$Companion;
 	public fun <init> ()V
+	public final fun get ()Ljava/util/Optional;
 	public final fun getFirstRegistered (Lkotlin/jvm/functions/Function1;)Ljava/util/Optional;
 	public final fun getREGISTERED ()Ljava/util/Set;
 	public final fun getUNREGISTERED ()Ljava/util/Set;
@@ -1556,6 +1557,7 @@ public final class dev/racci/minix/api/integrations/placeholders/PlaceholderMana
 }
 
 public abstract interface class dev/racci/minix/api/integrations/regions/Region {
+	public static final field Companion Ldev/racci/minix/api/integrations/regions/Region$Companion;
 	public abstract fun canAttack (Lorg/bukkit/entity/Player;Lorg/bukkit/entity/Entity;)Z
 	public abstract fun canBreak (Lorg/bukkit/entity/Player;)Z
 	public abstract fun canBuild (Lorg/bukkit/entity/Player;)Z
@@ -1566,6 +1568,9 @@ public abstract interface class dev/racci/minix/api/integrations/regions/Region
 	public abstract fun getWorld ()Lorg/bukkit/World;
 }
 
+public final class dev/racci/minix/api/integrations/regions/Region$Companion {
+}
+
 public abstract interface class dev/racci/minix/api/integrations/regions/RegionIntegration : dev/racci/minix/api/integrations/Integration {
 	public abstract fun canAttack (Ldev/racci/minix/api/utils/minecraft/BlockPos;Lorg/bukkit/World;Lorg/bukkit/entity/Player;Lorg/bukkit/entity/Entity;)Z
 	public abstract fun canBreak (Ldev/racci/minix/api/utils/minecraft/BlockPos;Lorg/bukkit/World;Lorg/bukkit/entity/Player;)Z

Minix-API/src/main/kotlin/dev/racci/minix/api/integrations/IntegrationManager.kt

@@ -18,14 +18,16 @@ open class IntegrationManager<I : Integration> {
         this.REGISTERED.add(integration)
     }
 
+    fun get(): Optional<I> = REGISTERED.firstOrNull().let { Optional.ofNullable(it) }
+
     /** Runs the action of the first found registered integration */
+    @Deprecated("Use get instead", ReplaceWith("get().ifPresent(action)"))
     fun onFirstRegistered(action: (I) -> Unit) {
-        if (this.REGISTERED.isEmpty()) return
-
-        this.REGISTERED.first().let(action)
+        this.REGISTERED.firstOrNull()?.let(action)
     }
 
     /** Runs the action of the first found registered integration and returns an optional of [T]. */
+    @Deprecated("Use get instead", ReplaceWith("get().map(action)"))
     fun <T : Any> getFirstRegistered(action: (I) -> T): Optional<T> {
         var result: T? = null
         this.onFirstRegistered { integration -> result = action(integration) }

Minix-API/src/main/kotlin/dev/racci/minix/api/integrations/regions/Region.kt

@@ -1,6 +1,7 @@
 package dev.racci.minix.api.integrations.regions
 
 import org.bukkit.World
+import org.bukkit.WorldCreator
 import org.bukkit.entity.Entity
 import org.bukkit.entity.Player
 import java.util.UUID
@@ -21,4 +22,24 @@ interface Region {
         player: Player,
         target: Entity
     ): Boolean
+
+    companion object {
+        internal val NONE: Region = object : Region {
+            override val id: Int = -1
+            override val name: String = "none"
+            override val owner: UUID = UUID.randomUUID()
+            override val world: World = WorldCreator("none").createWorld()!!
+
+            override fun canBuild(player: Player): Boolean = true
+
+            override fun canBreak(player: Player): Boolean = true
+
+            override fun canInteract(player: Player): Boolean = true
+
+            override fun canAttack(
+                player: Player,
+                target: Entity
+            ): Boolean = true
+        }
+    }
 }

Minix-API/src/main/kotlin/dev/racci/minix/api/integrations/regions/RegionManager.kt

@@ -12,38 +12,36 @@ object RegionManager : IntegrationManager<RegionIntegration>() {
     fun getRegion(
         pos: BlockPos,
         world: World
-    ): Optional<Region> = this.getFirstRegistered {
-        it.getRegion(pos, world).orElse(null)
-    }
+    ): Optional<Region> = this.get().map { it.getRegion(pos, world).orElse(Region.NONE) }
 
     fun insideRegion(
         pos: BlockPos,
         world: World
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.insideRegion(pos, world)
     }.orElse(false)
 
     fun canBuild(
         pos: BlockPos,
         world: World,
         player: Player
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.canBuild(pos, world, player)
     }.orElse(true)
 
     fun canBreak(
         pos: BlockPos,
         world: World,
         player: Player
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.canBreak(pos, world, player)
     }.orElse(true)
 
     fun canInteract(
         pos: BlockPos,
         world: World,
         player: Player
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.canInteract(pos, world, player)
     }.orElse(true)
 
@@ -52,31 +50,31 @@ object RegionManager : IntegrationManager<RegionIntegration>() {
         world: World,
         player: Player,
         target: Entity
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.canAttack(pos, world, player, target)
     }.orElse(true)
 
     fun ifWilderness(
         pos: BlockPos,
         world: World,
         action: () -> Unit
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.ifWilderness(pos, world, action)
     }.orElse(true) // if no region integration is found, assume wilderness
 
     fun ifTrustedInRegion(
         pos: BlockPos,
         player: Player,
         action: () -> Unit
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.ifTrustedInRegion(pos, player, action)
     }.orElse(false)
 
     fun ifWildernessOrTrusted(
         pos: BlockPos,
         player: Player,
         action: () -> Unit
-    ): Boolean = this.getFirstRegistered {
+    ): Boolean = this.get().map {
         it.ifWildernessOrTrusted(pos, player, action)
     }.orElse(true)
 }