feat: PagedSlateLayer

gradle.properties

@@ -15,6 +15,6 @@ kotlin_version=2.0.21
 fabric_kotlin_version=1.12.3
 
 # mod properties
-mod_version=1.3.0
+mod_version=1.3.1
 maven_group=net.mcbrawls
 mod_id=slate

src/main/kotlin/net/mcbrawls/slate/layer/PagedSlateLayer.kt

@@ -0,0 +1,132 @@
+package net.mcbrawls.slate.layer
+
+import net.mcbrawls.slate.tile.StackTile
+import net.mcbrawls.slate.tile.Tile
+import net.mcbrawls.slate.tile.Tile.Companion.tile
+import net.mcbrawls.slate.tile.TileClickCallback
+import net.minecraft.item.ItemStack
+
+/**
+ * A paginated slate layer.
+ */
+abstract class PagedSlateLayer(
+    /**
+     * The maximum slot count.
+     */
+    slotCount: Int,
+
+    width: Int = 1,
+    height: Int = 1,
+) : SlateLayer(width, height) {
+    /**
+     * The maximum slot count.
+     */
+    var slotCount: Int = slotCount
+        set(value) {
+            field = value
+
+            // update page
+            val oldPage = currentPage
+            currentPage = oldPage
+            if (currentPage == oldPage) {
+                updateTileGrid()
+            }
+        }
+
+    /**
+     * The maximum page.
+     */
+    val maxPage: Int get() = (slotCount - 1) / (width * height)
+
+    /**
+     * The currently displayed page.
+     */
+    var currentPage: Int = 0
+        set(value) {
+            val page = wrapPage(value, maxPage)
+
+            if (field == page) {
+                return
+            }
+
+            field = page
+            updateTileGrid()
+
+            // callbackHandler.collectCallbacks<SlateLayerPageChangeCallback>().invoke()
+        }
+
+    init {
+        updateTileGrid()
+    }
+
+    /**
+     * Creates a tile for the given index.
+     */
+    abstract fun createTile(
+        /**
+         * The calculated index from all tiles of all pages.
+         */
+        index: Int
+    ): Tile?
+
+    /**
+     * Updates the tile grid to new tiles for the active page.
+     */
+    fun updateTileGrid() {
+        tiles.clear()
+
+        if (slotCount < 0) {
+            return
+        }
+
+        val size = tiles.baseSize
+        val baseIndex = currentPage * size
+        (0 until size).forEach { index ->
+            val calculatedIndex = baseIndex + index
+            val tile = createTile(calculatedIndex)
+            tiles[index] = tile
+        }
+    }
+
+    fun createPageChangeTile(title: String, modifier: (Int) -> Int, stack: ItemStack, callback: TileClickCallback? = null): Tile {
+        if (maxPage <= 0) {
+            return StackTile.EMPTY
+        }
+
+        return tile(stack) {
+            tooltip(title)
+
+            callbacks {
+                onClick { slate, tile, context ->
+                    callback?.onClick(slate, tile, context)
+                    currentPage = modifier.invoke(currentPage)
+                }
+            }
+        }
+    }
+
+    fun createNextPageTile(stack: ItemStack, callback: TileClickCallback? = null): Tile {
+        return createPageChangeTile("Next Page", Int::unaryPlus, stack, callback)
+    }
+
+    fun createPreviousPageTile(stack: ItemStack, callback: TileClickCallback? = null): Tile {
+        return createPageChangeTile("Previous Page", Int::unaryMinus, stack, callback)
+    }
+
+    companion object {
+        /**
+         * Wraps a page around a maximum page value.
+         */
+        fun wrapPage(page: Int, maxPage: Int): Int {
+            if (page > maxPage) {
+                return 0
+            }
+
+            if (page < 0) {
+                return maxPage
+            }
+
+            return page
+        }
+    }
+}

src/main/kotlin/net/mcbrawls/slate/layer/callback/SlateLayerCallbackHandler.kt

@@ -15,6 +15,13 @@ open class SlateLayerCallbackHandler {
         callbacks.add(callback)
     }
 
+    /**
+     * Adds a callback invoked on the layer if a page changes.
+     */
+    fun onPageChange(callback: SlateLayerPageChangeCallback) {
+        callbacks.add(callback)
+    }
+
     /**
      * Combines all callbacks for the given type into one callable object.
      */

src/main/kotlin/net/mcbrawls/slate/layer/callback/SlateLayerPageChangeCallback.kt

@@ -0,0 +1,3 @@
+package net.mcbrawls.slate.layer.callback
+
+fun interface SlateLayerPageChangeCallback : SlateLayerCallback

src/main/kotlin/net/mcbrawls/slate/tile/StackTile.kt

@@ -5,7 +5,7 @@ import net.minecraft.item.Item
 import net.minecraft.item.ItemStack
 import net.minecraft.server.network.ServerPlayerEntity
 
-class StackTile(var stack: ItemStack) : Tile() {
+class StackTile(var stack: ItemStack = ItemStack.EMPTY) : Tile() {
     constructor(item: Item) : this(ItemStack(item))
 
     override fun createBaseStack(slate: Slate, player: ServerPlayerEntity): ItemStack {
@@ -16,4 +16,8 @@ class StackTile(var stack: ItemStack) : Tile() {
         val stackStr = stack.toString()
         return "StackTile{$stackStr}"
     }
+
+    companion object {
+        val EMPTY = StackTile()
+    }
 }

src/main/kotlin/net/mcbrawls/slate/tile/TileGrid.kt

@@ -98,6 +98,13 @@ open class TileGrid(val width: Int, val height: Int) {
         return set(index, null)
     }
 
+    /**
+     * Clears all tile slots.
+     */
+    fun clear() {
+        return tiles.fill(null)
+    }
+
     /**
      * Sets a redirect on this tile grid.
      */