feat: advanced inventory management

Author: InvalidJoker

src/main/kotlin/cc/modlabs/kpaper/coroutines/PaperRunnable.kt

@@ -0,0 +1,27 @@
+package cc.modlabs.kpaper.coroutines
+
+import cc.modlabs.kpaper.main.PluginInstance
+import org.bukkit.Bukkit
+
+/**
+ * Executes the given [runnable] with the given [delay].
+ * Either sync or async (specified by the [sync] parameter).
+ */
+fun taskRunLater(delay: Long, sync: Boolean = true, runnable: () -> Unit) {
+    if (sync)
+        Bukkit.getScheduler().runTaskLater(PluginInstance, runnable, delay)
+    else
+        Bukkit.getScheduler().runTaskLaterAsynchronously(PluginInstance, runnable, delay)
+}
+
+/**
+ * Executes the given [runnable] either
+ * sync or async (specified by the [sync] parameter).
+ */
+fun taskRun(sync: Boolean = true, runnable: () -> Unit) {
+    if (sync) {
+        sync(runnable)
+    } else {
+        async(runnable)
+    }
+}

src/main/kotlin/cc/modlabs/kpaper/extensions/InventoryExtensions.kt

@@ -4,6 +4,7 @@ import cc.modlabs.kpaper.consts.NAMESPACE_GUI_IDENTIFIER
 import cc.modlabs.kpaper.consts.NAMESPACE_ITEM_IDENTIFIER
 import cc.modlabs.kpaper.inventory.ItemBuilder
 import cc.modlabs.kpaper.inventory.toItemBuilder
+import dev.fruxz.ascend.extension.isNull
 import dev.fruxz.stacked.text
 import org.bukkit.Material
 import org.bukkit.NamespacedKey
@@ -163,26 +164,120 @@ fun Inventory.setItem(range: IntProgression, item: ItemStack) {
 }
 
 fun fillEmptyAndOpenInventory(player: Player, inv: Inventory, identifier: String? = null, vararg identifiers: Map<NamespacedKey, String>? = arrayOf()) {
-    fillEmpty(inv)
+    fillEmpty(inv, PLACEHOLDER_GRAY)
     if (identifier != null) inv.identify(identifier, *identifiers)
     player.openInventory(inv)
 }
 
-fun Inventory.fillEmpty(filler: ItemStack, identifier: String? = null, vararg identifiers: Map<NamespacedKey, String>? = arrayOf()) {
-    for (i in 0 until this.size) {
-        if (this.getItem(i) == null || this.getItem(i)!!.type == Material.AIR) {
-            this.setItem(i, filler)
-        }
-    }
-    if (identifier != null) this.identify(identifier, *identifiers)
+
+fun fillEmptyAndOpenInventoryWithCustomSpacer(player: Player, inv: Inventory, spacer: ItemStack, identifier: String? = null, vararg identifiers: Map<NamespacedKey, String>? = arrayOf()) {
+    fillEmpty(inv, spacer)
+    if (identifier != null) inv.identify(identifier, *identifiers)
+    player.openInventory(inv)
 }
 
-fun fillEmpty(inventory: Inventory, identifier: String? = null, vararg identifiers: Map<NamespacedKey, String>? = arrayOf()) {
-    val item = PLACEHOLDER_GRAY
+fun fillEmpty(inventory: Inventory, customSpacer: ItemStack, identifier: String? = null, vararg identifiers: Map<NamespacedKey, String>? = arrayOf()) {
     for (i in 0 until inventory.size) {
         if (inventory.getItem(i) == null || inventory.getItem(i)!!.type == Material.AIR) {
-            inventory.setItem(i, item)
+            inventory.setItem(i, customSpacer)
         }
     }
     if (identifier != null) inventory.identify(identifier, *identifiers)
+}
+
+fun Inventory.fillEmpty(filler: ItemStack, identifier: String? = null, vararg identifiers: Map<NamespacedKey, String>? = arrayOf()) {
+    fillEmpty(this, filler, identifier, *identifiers)
+}
+
+fun Inventory.arrangeItemsAround(newItem: ItemStack) {
+    val centerSlot = this.getMiddleSlot()
+    val slots = arrayOf(centerSlot - 9, centerSlot - 1, centerSlot + 1, centerSlot + 9)
+
+    for (slot in slots) {
+        // Check if the slot is within the inventory bounds
+        if (slot in this.contents.indices) {
+            // Check if the slot is already occupied
+            if (this.getItem(slot) == null || this.getItem(slot)!!.type == Material.AIR || this.getItem(slot)!!.hasKey("spacer")) {
+                this.setItem(slot, newItem)
+                break
+            }
+        }
+    }
+}
+
+fun Inventory.swapItems(firstSlot: Int, secondSlot: Int, newItem: ItemStack) {
+    // Swap the two items
+    val tempItem = this.getItem(firstSlot)
+    this.setItem(firstSlot, this.getItem(secondSlot))
+    this.setItem(secondSlot, tempItem)
+
+    // Place the new item in the empty slot
+    if (this.getItem(firstSlot).isNull) {
+        this.setItem(firstSlot, newItem)
+    } else if (this.getItem(secondSlot).isNull) {
+        this.setItem(secondSlot, newItem)
+    }
+}
+
+fun Inventory.getEmptySlot(): Int {
+    for (i in 0 until this.size) {
+        if (this.getItem(i) == null || this.getItem(i)!!.type == Material.AIR) {
+            return i
+        }
+    }
+    return -1
+}
+
+fun Inventory.setItemInMiddle(item: ItemStack) {
+    val roundedMiddle = this.size / 2
+    val middle = if (roundedMiddle % 2 == 0) roundedMiddle else roundedMiddle
+    this.setItem(middle, item)
+}
+
+fun Inventory.getMiddleSlot(): Int {
+    val roundedMiddle = this.size / 2
+    return if (roundedMiddle % 2 == 0) roundedMiddle else roundedMiddle
+}
+
+fun Inventory.setLeftUpperCorner(item: ItemStack) {
+    this.setItem(0, item)
+}
+
+fun Inventory.setRightUpperCorner(item: ItemStack) {
+    this.setItem(8, item)
+}
+
+fun Inventory.setMiddleLeft(item: ItemStack) {
+    val rows = this.size / 9
+    val middle = if (rows % 2 == 0) rows / 2 - 1 else rows / 2
+    this.setItem(middle * 9, item)
+}
+
+fun Inventory.setMiddleRight(item: ItemStack) {
+    val rows = this.size / 9
+    val middle = if (rows % 2 == 0) rows / 2 - 1 else rows / 2
+    this.setItem(middle * 9 + 8, item)
+}
+
+fun Inventory.setUpperMiddle(item: ItemStack) {
+    this.setItem(4, item)
+}
+
+fun Inventory.setLowerMiddle(item: ItemStack) {
+    this.setItem(this.size - 5, item)
+}
+
+fun Inventory.setLeftLowerCorner(item: ItemStack) {
+    this.setItem(this.size - 9, item)
+}
+
+fun Inventory.setRightLowerCorner(item: ItemStack) {
+    this.setItem(this.size - 1, item)
+}
+
+fun ItemStack.hasKey(namespacedKey: String): Boolean {
+    return this.itemMeta?.persistentDataContainer?.has(
+        pluginKey(namespacedKey),
+        PersistentDataType.STRING
+    ) ?: false
 }

src/main/kotlin/cc/modlabs/kpaper/extensions/LocationExtension.kt

@@ -91,4 +91,36 @@ fun loc2Str(location: Location): String {
     loc += location.yaw.toString() + ","
     loc += location.pitch
     return loc
+}
+
+
+fun Location.asSafeLocation(): Location {
+    // Now we test if the location (2 blocks high) is occupied and if so, we move up until we find a free spot
+    var location = this.clone()
+    while ((location.block.type.isSolid || location.clone().add(0.0, 1.0, 0.0).block.type.isSolid)) {
+        location = location.add(0.0, 1.0, 0.0)
+    }
+    return location
+}
+
+fun Location.asSafeLocationOrNull(): Location? {
+    // Now we test if the location (2 blocks high) is occupied and if so, we move up until we find a free spot
+    var location = this.clone()
+    while ((location.block.type.isSolid || location.clone().add(0.0, 1.0, 0.0).block.type.isSolid)) {
+        location = location.add(0.0, 1.0, 0.0)
+    }
+    if(location.y > 319) return null
+    return location
+}
+
+fun Location.isInRadius(middle: Location, radius: Int): Boolean {
+    return this.x in middle.x - radius..middle.x + radius && this.z in middle.z - radius..middle.z + radius
+}
+
+fun Location.inWorld(world: World) = this.clone().apply { this.world = world }
+
+fun Location.inWorld(worlds: String) = this.clone().apply { this.world = Bukkit.getWorld(worlds.lowercase()) }
+
+fun Location.toNorth(): Location {
+    return this.apply { this.yaw = 180.0f; this.pitch = 0f }
 }

src/main/kotlin/cc/modlabs/kpaper/inventory/ItemBuilder.kt

@@ -1,5 +1,8 @@
-package cc.modlabs.kpaper.inventory
+@file:Suppress("unused")
 
+package cc.modlabs.kpaper.inventory
+
+import cc.modlabs.kpaper.coroutines.taskRunLater
 import com.mojang.authlib.GameProfile
 import com.mojang.authlib.properties.Property
 import dev.fruxz.stacked.text
@@ -18,9 +21,9 @@ import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.ItemMeta
 import org.bukkit.inventory.meta.SkullMeta
 import org.bukkit.persistence.PersistentDataType
-import org.jetbrains.annotations.ApiStatus
 import java.lang.reflect.Field
 import java.util.*
+import java.util.concurrent.TimeUnit
 
 
 /**
@@ -338,7 +341,7 @@ class ItemBuilder(material: Material, count: Int = 1, dsl: ItemBuilder.() -> Uni
      */
     fun lore(vararg lores: String): ItemBuilder {
         val meta = itemStack.itemMeta
-        var lore = listOf<Component>()
+        val lore = mutableListOf<Component>()
 
         lores.forEach {
             val lines = it.split("\n")
@@ -435,27 +438,15 @@ class ItemBuilder(material: Material, count: Int = 1, dsl: ItemBuilder.() -> Uni
 
     /**
      * Sets the equippable state of the item in the specified slot.
-     * This method is not yet supported in PaperMC 1.21.1.
      */
-    @ApiStatus.Internal
-    fun setEquippable(slot: EquipmentSlot, equippable: Boolean): ItemBuilder {
+    fun setEquippable(slot: EquipmentSlot): ItemBuilder {
         val meta = itemStack.itemMeta
 
-        TODO("Waiting for 1.21.2+ support")
+        val equippable = meta.equippable
 
-        itemStack.itemMeta = meta
-        return this
-    }
+        equippable.slot = slot
 
-    /**
-     * Sets the consumable state of the item.
-     * This method is not yet supported in PaperMC 1.21.1.
-     */
-    @ApiStatus.Internal
-    fun setConsumable(consumable: Boolean): ItemBuilder {
-        val meta = itemStack.itemMeta
-
-        TODO("Waiting for 1.21.2+ support")
+        meta.setEquippable(equippable)
 
         itemStack.itemMeta = meta
         return this
@@ -594,7 +585,7 @@ class ItemBuilder(material: Material, count: Int = 1, dsl: ItemBuilder.() -> Uni
         )
 
         fun fromItemStack(itemStack: ItemStack): ItemBuilder {
-            var mat =
+            val mat =
                 if (invalidMaterials.contains(itemStack.type)) Material.GRASS_BLOCK else itemStack.type
             val builder = ItemBuilder(mat)
             builder.itemStack = itemStack
@@ -610,7 +601,7 @@ class ItemBuilder(material: Material, count: Int = 1, dsl: ItemBuilder.() -> Uni
  * @return The resulting ItemBuilder.
  */
 fun Material.toItemBuilder(dsl: ItemBuilder.() -> Unit = {}): ItemBuilder {
-    var mat = if (ItemBuilder.invalidMaterials.contains(this)) Material.GRASS_BLOCK else this
+    val mat = if (ItemBuilder.invalidMaterials.contains(this)) Material.GRASS_BLOCK else this
     return ItemBuilder(mat).apply(dsl)
 }
 
@@ -621,9 +612,21 @@ fun Material.toItemBuilder(dsl: ItemBuilder.() -> Unit = {}): ItemBuilder {
  * @return the converted ItemBuilder.
  */
 fun ItemStack.toItemBuilder(dsl: ItemBuilder.() -> Unit = {}): ItemBuilder {
-    var mat = if (ItemBuilder.invalidMaterials.contains(this.type)) Material.GRASS_BLOCK else this.type
+    val mat = if (ItemBuilder.invalidMaterials.contains(this.type)) Material.GRASS_BLOCK else this.type
     val builder = ItemBuilder(mat)
     builder.itemStack = this
     builder.dsl()
     return builder
+}
+
+fun ItemStack.changeNameForTime(name: String, time: Long, unit: TimeUnit = TimeUnit.SECONDS, afterTask: () -> Unit = {}) {
+    val oldName = this.itemMeta.displayName()
+    val meta = this.itemMeta
+    meta.displayName(text(name))
+    this.itemMeta = meta
+    taskRunLater(unit.toSeconds(time) * 20L) {
+        meta.displayName(oldName)
+        this.itemMeta = meta
+        afterTask()
+    }
 }

src/main/kotlin/cc/modlabs/kpaper/world/Direction.kt

@@ -0,0 +1,5 @@
+package cc.modlabs.kpaper.world
+
+enum class Direction {
+    MIDDLE, NORTH, NORTH_EAST, EAST, SOUTH_EAST, SOUTH(), SOUTH_WEST, WEST, NORTH_WEST
+}