Updated to 6.43.3

Fix: Skull texture out of bounds error

eco-api/src/main/java/com/willfp/eco/core/gui/menu/MenuBuilder.java

@@ -107,7 +107,7 @@ public interface MenuBuilder extends PageBuilder {
      * @return The builder.
      */
     default MenuBuilder addPage(@NotNull final Page page) {
-        return this.addComponent(MenuLayer.TOP, 1, 1, page);
+        return this.addComponent(MenuLayer.UPPER, 1, 1, page);
     }
 
     /**

eco-api/src/main/java/com/willfp/eco/core/gui/page/PageChanger.java

@@ -79,7 +79,7 @@ public final class PageChanger implements GUIComponent {
             return null;
         }
 
-        if (page >= maxPage - 1 && this.direction == Direction.FORWARDS) {
+        if (page >= maxPage && this.direction == Direction.FORWARDS) {
             return null;
         }
 

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/menu/EcoMenu.kt

@@ -20,7 +20,7 @@ import org.bukkit.inventory.ItemStack
 class EcoMenu(
     private val rows: Int,
     private val columns: Int,
-    private val componentsAtPoints: Map<GUIPosition, List<OffsetComponent>>,
+    private val components: LayeredComponents,
     private val title: String,
     private val onClose: List<CloseHandler>,
     private val onRender: List<(Player, Menu) -> Unit>,
@@ -28,38 +28,19 @@ class EcoMenu(
     private val menuEventHandlers: List<MenuEventHandler<*>>,
     private val allowsChangingHeldItem: Boolean
 ) : Menu {
-    private fun getPossiblyReactiveSlot(row: Int, column: Int, player: Player?, menu: Menu?): Slot {
+    private fun getPossiblyReactiveSlot(row: Int, column: Int, player: Player?): Slot {
         if (row < 1 || row > this.rows || column < 1 || column > this.columns) {
             return emptyFillerSlot
         }
 
-        val guiPosition = GUIPosition(row, column)
-        val components = componentsAtPoints[guiPosition] ?: return emptyFillerSlot
-
-        for (component in components) {
-            val found = if (player != null && menu != null) component.component.getSlotAt(
-                component.rowOffset,
-                component.columnOffset,
-                player,
-                menu
-            ) else component.component.getSlotAt(
-                component.rowOffset,
-                component.columnOffset
-            )
-
-            if (found != null) {
-                return found
-            }
-        }
-
-        return emptyFillerSlot
+        return components.getSlotAt(row, column, player, this)
     }
 
     override fun getSlot(row: Int, column: Int): Slot =
-        getPossiblyReactiveSlot(row, column, null, null)
+        getPossiblyReactiveSlot(row, column, null)
 
     override fun getSlot(row: Int, column: Int, player: Player, menu: Menu): Slot =
-        getPossiblyReactiveSlot(row, column, player, menu)
+        getPossiblyReactiveSlot(row, column, player)
 
     override fun open(player: Player): Inventory {
         val inventory = if (columns == 9) {

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/menu/EcoMenuBuilder.kt

@@ -86,7 +86,7 @@ class EcoMenuBuilder(
     }
 
     override fun build(): Menu {
-        val layeredComponents = mutableMapOf<MenuLayer, MutableMap<GUIPosition, MutableList<OffsetComponent>>>()
+        val layeredComponents = LayeredComponents()
 
         // 5 nested for loops? Shut up. Silence. Quiet.
         for (layer in MenuLayer.values()) {
@@ -107,11 +107,14 @@ class EcoMenuBuilder(
 
                             val point = GUIPosition(row, column)
 
-                            layeredComponents.computeIfAbsent(layer) { mutableMapOf() }
-                                .computeIfAbsent(point) { mutableListOf() } += OffsetComponent(
-                                component,
-                                rowOffset,
-                                columnOffset
+                            layeredComponents.addOffsetComponent(
+                                layer,
+                                point,
+                                OffsetComponent(
+                                    component,
+                                    rowOffset,
+                                    columnOffset
+                                )
                             )
                         }
                     }
@@ -119,18 +122,10 @@ class EcoMenuBuilder(
             }
         }
 
-        val componentsAtPoints = mutableMapOf<GUIPosition, MutableList<OffsetComponent>>()
-
-        for (menuLayer in MenuLayer.values()) {
-            for ((anchor, offsetComponents) in layeredComponents[menuLayer] ?: emptyMap()) {
-                componentsAtPoints[anchor] = offsetComponents
-            }
-        }
-
         return EcoMenu(
             rows,
             columns,
-            componentsAtPoints,
+            layeredComponents,
             title,
             onClose,
             onRender,

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/menu/LayeredComponents.kt

@@ -0,0 +1,46 @@
+package com.willfp.eco.internal.gui.menu
+
+import com.willfp.eco.core.gui.menu.Menu
+import com.willfp.eco.core.gui.menu.MenuLayer
+import com.willfp.eco.core.gui.slot.Slot
+import org.bukkit.entity.Player
+
+class LayeredComponents {
+    private val layers = mutableMapOf<MenuLayer, Map<GUIPosition, List<OffsetComponent>>>()
+
+    fun getSlotAt(row: Int, column: Int, player: Player?, menu: Menu): Slot {
+        val guiPosition = GUIPosition(row, column)
+
+        for (layer in MenuLayer.values().reversed()) {
+            val componentsAtPoints = layers[layer] ?: continue
+
+            val components = componentsAtPoints[guiPosition] ?: continue
+
+            for (component in components) {
+                val found = if (player != null) component.component.getSlotAt(
+                    component.rowOffset,
+                    component.columnOffset,
+                    player,
+                    menu
+                ) else component.component.getSlotAt(
+                    component.rowOffset,
+                    component.columnOffset
+                )
+
+                if (found != null) {
+                    return found
+                }
+            }
+        }
+
+        return emptyFillerSlot
+    }
+
+    fun addOffsetComponent(layer: MenuLayer, position: GUIPosition, component: OffsetComponent) {
+        val inLayer = layers[layer]?.toMutableMap() ?: mutableMapOf()
+        val atPosition = inLayer[position]?.toMutableList() ?: mutableListOf()
+        atPosition.add(component)
+        inLayer[position] = atPosition
+        layers[layer] = inLayer
+    }
+}

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/Skull.kt

@@ -29,7 +29,27 @@ var SkullMeta.texture: String?
             setProfile.isAccessible = true
         }
 
-        if (base64 == null) {
+        /* This length check below was lost in the conversion. For some reason the base64
+        * string is length 8 when this is called pretty frequently, causing an
+        * out of bounds exception.
+        *
+        * Could not pass event EntityPotionEffectEvent to Talismans v5.116.0
+        * java.lang.StringIndexOutOfBoundsException: begin -12, end 8, length 8
+        * at java.lang.String.checkBoundsBeginEnd(String.java:4604) ~[?:?]
+        * at java.lang.String.substring(String.java:2707) ~[?:?]
+        * at java.lang.String.substring(String.java:2680) ~[?:?]
+        * at com.willfp.eco.internal.spigot.proxy.v1_19_R1.common.SkullKt.setTexture(Skull.kt:36)
+        *
+        if (base64.length < 20) {
+            return
+        }
+        *
+        * ^ Update to this comment: a length 8 string ("textures") was being sent
+        * because the get() method wasn't working right. This has been fixed, but the
+        * check needs to remain implemented.
+        */
+
+        if (base64 == null || base64.length < 20) {
             setProfile.invoke(this, null)
         } else {
             val uuid = UUID(

gradle.properties

@@ -1,3 +1,3 @@
-version = 6.43.1
+version = 6.43.3
 plugin-name = eco
 kotlin.code.style = official