feat: SlateLayer extendability, callbacks, and dsl

src/main/kotlin/net/mcbrawls/slate/Slate.kt

@@ -1,9 +1,10 @@
 package net.mcbrawls.slate
 
-import net.mcbrawls.slate.callback.SlateCallbackHandler
+import net.mcbrawls.slate.callback.handler.SlateCallbackHandler
 import net.mcbrawls.slate.callback.SlateCloseCallback
 import net.mcbrawls.slate.callback.SlateOpenCallback
 import net.mcbrawls.slate.callback.SlateTickCallback
+import net.mcbrawls.slate.layer.SlateLayer
 import net.mcbrawls.slate.screen.SlateScreenHandler
 import net.mcbrawls.slate.screen.SlateScreenHandlerFactory
 import net.mcbrawls.slate.screen.slot.TileClickContext
@@ -33,7 +34,7 @@ open class Slate {
     /**
      * Layers displayed on top of the base tile grid.
      */
-    val layers: MutableList<LayerData> = mutableListOf()
+    val layers: MutableList<LayerWithIndex> = mutableListOf()
 
     /**
      * Handles all callbacks for this slate.
@@ -73,6 +74,23 @@ open class Slate {
         callbackHandler = callbackHandler.apply(factory)
     }
 
+    /**
+     * Adds a layer to this slate.
+     * @return the created layer
+     */
+    inline fun layer(
+        index: Int,
+        width: Int,
+        height: Int,
+        factory: SlateLayer.Factory = SlateLayer.Factory(::SlateLayer),
+        builder: SlateLayer.() -> Unit
+    ) : SlateLayer {
+        val layer = factory.create(width, height)
+        layer.apply(builder)
+        layers.add(LayerWithIndex(index, layer))
+        return layer
+    }
+
     /**
      * Builds a slate with this slate as the parent.
      */
@@ -125,6 +143,11 @@ open class Slate {
 
         // invoke callbacks
         callbackHandler.collectCallbacks<SlateTickCallback>().invoke(this, player)
+
+        // layer ticks
+        layers.forEach { indexedLayer ->
+            indexedLayer.layer.onTick(this, player)
+        }
     }
 
     internal fun onClosed(player: ServerPlayerEntity) {
@@ -220,14 +243,22 @@ open class Slate {
         return false
     }
 
+    /**
+     * Removes a layer from this slate.
+     * @return if the layer was removed
+     */
+    fun removeLayer(layer: SlateLayer): Boolean {
+        return layers.removeIf { it.layer == layer }
+    }
+
     override fun toString(): String {
         return "Slate{${tiles.screenHandlerType}:$title, $tiles}"
     }
 
     /**
      * The stored data for an active layer.
      */
-    data class LayerData(
+    data class LayerWithIndex(
         val index: Int,
         val layer: SlateLayer,
     )

src/main/kotlin/net/mcbrawls/slate/callback/SlateCallbackHandler.kt → src/main/kotlin/net/mcbrawls/slate/callback/handler/SlateCallbackHandler.kt

@@ -1,6 +1,11 @@
-package net.mcbrawls.slate.callback
+package net.mcbrawls.slate.callback.handler
 
 import net.mcbrawls.slate.Slate
+import net.mcbrawls.slate.callback.SlateCallback
+import net.mcbrawls.slate.callback.SlateCloseCallback
+import net.mcbrawls.slate.callback.SlateInputCallback
+import net.mcbrawls.slate.callback.SlateOpenCallback
+import net.mcbrawls.slate.callback.SlateTickCallback
 
 /**
  * Handles callbacks for instances of [Slate].

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

@@ -0,0 +1,38 @@
+package net.mcbrawls.slate.layer
+
+import net.mcbrawls.slate.Slate
+import net.mcbrawls.slate.layer.callback.SlateLayerCallbackHandler
+import net.mcbrawls.slate.layer.callback.SlateLayerTickCallback
+import net.mcbrawls.slate.tile.TileGrid
+import net.minecraft.server.network.ServerPlayerEntity
+
+/**
+ * An instance of a layer on a slate.
+ */
+open class SlateLayer(
+    val width: Int,
+    val height: Int,
+) {
+    val tiles: TileGrid = TileGrid(width, height)
+
+    /**
+     * Handles all callbacks for this layer.
+     */
+    open var callbackHandler: SlateLayerCallbackHandler = SlateLayerCallbackHandler()
+
+    /**
+     * Provides a factory for setting up callbacks of this layer.
+     */
+    inline fun callbacks(factory: SlateLayerCallbackHandler.() -> Unit) {
+        callbackHandler = callbackHandler.apply(factory)
+    }
+
+    internal fun onTick(slate: Slate, player: ServerPlayerEntity) {
+        // invoke callbacks
+        callbackHandler.collectCallbacks<SlateLayerTickCallback>().invoke(slate, this, player)
+    }
+
+    fun interface Factory {
+        fun create(width: Int, height: Int): SlateLayer
+    }
+}

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

@@ -0,0 +1,9 @@
+package net.mcbrawls.slate.layer.callback
+
+import net.mcbrawls.slate.Slate
+import net.mcbrawls.slate.layer.SlateLayer
+import net.minecraft.server.network.ServerPlayerEntity
+
+fun interface SlateLayerCallback {
+    operator fun invoke(slate: Slate, layer: SlateLayer, player: ServerPlayerEntity)
+}

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

@@ -0,0 +1,28 @@
+package net.mcbrawls.slate.layer.callback
+
+import net.mcbrawls.slate.layer.SlateLayer
+
+/**
+ * Handles callbacks for instances of [SlateLayer].
+ */
+open class SlateLayerCallbackHandler {
+    val callbacks: MutableList<SlateLayerCallback> = mutableListOf()
+
+    /**
+     * Adds a callback invoked on the layer every game tick.
+     */
+    fun onTick(callback: SlateLayerTickCallback) {
+        callbacks.add(callback)
+    }
+
+    /**
+     * Combines all callbacks for the given type into one callable object.
+     */
+    inline fun <reified T : SlateLayerCallback> collectCallbacks(): SlateLayerCallback {
+        return SlateLayerCallback { slate, layer, player ->
+            callbacks
+                .filterIsInstance<T>()
+                .forEach { callback -> callback.invoke(slate, layer, player) }
+        }
+    }
+}

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

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

src/test/kotlin/net/mcbrawls/slate/test/SlateTest.kt

@@ -5,7 +5,7 @@ import net.fabricmc.fabric.api.event.player.UseItemCallback
 import net.mcbrawls.slate.InventorySlate
 import net.mcbrawls.slate.Slate
 import net.mcbrawls.slate.Slate.Companion.slate
-import net.mcbrawls.slate.SlateLayer
+import net.mcbrawls.slate.layer.SlateLayer
 import net.mcbrawls.slate.SlatePlayer
 import net.mcbrawls.slate.screen.slot.ClickType
 import net.mcbrawls.slate.tile.Tile.Companion.tile
@@ -34,12 +34,26 @@ class SlateTest : ModInitializer {
                 val slate = slate {
                     title = Text.literal("Slate Innit")
 
-                    // TODO coordinates and avoid direct creation of LayerData!
-                    layers.add(Slate.LayerData(4, SlateLayer(3, 2).apply {
+                    layer(4, 3, 2) {
                         for (i in 0 until size) {
-                            tiles[i] = tile(ItemStack(Items.STONE))
+                            tiles[i] = tile(ItemStack(Items.STONE)) {
+                                tooltip(Text.literal("Layer tile at $i"))
+                            }
                         }
-                    }))
+
+                        callbacks {
+                            onTick { _, _, player ->
+                                if (player.age % 20 == 0) {
+                                    val maybeItemRef = Registries.ITEM.getRandom(Random.create())
+                                    maybeItemRef.ifPresent { ref ->
+                                        val item = ref.value()
+                                        val tile = tiles[0, 1]
+                                        tile?.stack = ItemStack(item)
+                                    }
+                                }
+                            }
+                        }
+                    }
 
                     tiles[0, 0] = tile()
                     tiles[1, 0] = tile(ItemStack(Items.WHITE_WOOL))