feat: anvil input

src/main/java/net/mcbrawls/slate/mixin/ServerPlayNetworkHandlerMixin.java

@@ -7,6 +7,7 @@
 import net.minecraft.network.ClientConnection;
 import net.minecraft.network.NetworkThreadUtils;
 import net.minecraft.network.packet.c2s.play.CloseHandledScreenC2SPacket;
+import net.minecraft.network.packet.c2s.play.RenameItemC2SPacket;
 import net.minecraft.network.packet.s2c.play.OpenScreenS2CPacket;
 import net.minecraft.screen.ScreenHandler;
 import net.minecraft.screen.ScreenHandlerType;
@@ -17,6 +18,9 @@
 import net.minecraft.server.network.ServerPlayerEntity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(ServerPlayNetworkHandler.class)
 public abstract class ServerPlayNetworkHandlerMixin extends ServerCommonNetworkHandler {
@@ -48,4 +52,13 @@ private void handleScreenClose(CloseHandledScreenC2SPacket packet, Operation<Voi
 
         original.call(packet);
     }
+
+    @Inject(method = "onRenameItem", at = @At("TAIL"))
+    private void handleAnvilInput(RenameItemC2SPacket packet, CallbackInfo ci) {
+        if (this.player.currentScreenHandler instanceof SlateScreenHandler handler) {
+            String input = packet.getName();
+            handler.onAnvilInput(input);
+            handler.syncState();
+        }
+    }
 }

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

@@ -69,6 +69,13 @@ open class Slate {
         }
     }
 
+    /**
+     * Called when the client input changes.
+     */
+    open fun onAnvilInput(player: ServerPlayerEntity, input: String) {
+        callbackHandler.collectInputCallbacks().onInput(this, player, input)
+    }
+
     /**
      * Opens a slate for the given player.
      * @return whether the slate was opened successfully

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

@@ -7,6 +7,7 @@ import net.mcbrawls.slate.Slate
  */
 open class SlateCallbackHandler {
     val callbacks: MutableList<SlateCallback> = mutableListOf()
+    val inputCallbacks: MutableList<SlateInputCallback> = mutableListOf()
 
     /**
      * Adds a callback invoked when the slate is opened.
@@ -29,6 +30,13 @@ open class SlateCallbackHandler {
         callbacks.add(callback)
     }
 
+    /**
+     * Adds a callback invoked when the slate input changes, namely for anvil screen handler types.
+     */
+    fun onInput(callback: SlateInputCallback) {
+        inputCallbacks.add(callback)
+    }
+
     /**
      * Combines all callbacks for the given type into one callable object.
      */
@@ -39,4 +47,13 @@ open class SlateCallbackHandler {
                 .forEach { callback -> callback.invoke(slate, player) }
         }
     }
+
+    /**
+     * Combines all callbacks for the given type into one callable object.
+     */
+    fun collectInputCallbacks(): SlateInputCallback {
+        return SlateInputCallback { slate, player, input ->
+            inputCallbacks.forEach { callback -> callback.onInput(slate, player, input) }
+        }
+    }
 }

src/main/kotlin/net/mcbrawls/slate/callback/SlateInputCallback.kt

@@ -0,0 +1,8 @@
+package net.mcbrawls.slate.callback
+
+import net.mcbrawls.slate.Slate
+import net.minecraft.server.network.ServerPlayerEntity
+
+fun interface SlateInputCallback {
+    fun onInput(slate: Slate, player: ServerPlayerEntity, input: String)
+}

src/main/kotlin/net/mcbrawls/slate/screen/SlateScreenHandler.kt

@@ -42,11 +42,10 @@ class SlateScreenHandler(
         }
     }
 
-    override fun syncState() {
-        super.syncState()
-
-        // manually update offhand
-        clearOffhandSlotClient()
+    fun onAnvilInput(input: String) {
+        if (player is ServerPlayerEntity) {
+            slate.onAnvilInput(player, input)
+        }
     }
 
     override fun sendContentUpdates() {
@@ -66,10 +65,6 @@ class SlateScreenHandler(
         }
     }
 
-    override fun quickMove(player: PlayerEntity, slot: Int): ItemStack {
-        return ItemStack.EMPTY
-    }
-
     override fun internalOnSlotClick(slotIndex: Int, button: Int, actionType: SlotActionType, player: PlayerEntity) {
         val isOffhandSwap = actionType == SlotActionType.SWAP && button == PlayerInventory.OFF_HAND_SLOT
         if (isOffhandSwap) {
@@ -85,12 +80,11 @@ class SlateScreenHandler(
         }
     }
 
-    override fun canInsertIntoSlot(slot: Slot): Boolean {
-        return false
-    }
+    override fun syncState() {
+        super.syncState()
 
-    override fun canUse(player: PlayerEntity): Boolean {
-        return true
+        // manually update offhand
+        clearOffhandSlotClient()
     }
 
     /**
@@ -110,4 +104,16 @@ class SlateScreenHandler(
         val inventoryPacket = InventoryS2CPacket(playerScreenHandler.syncId, playerScreenHandler.nextRevision(), playerScreenHandler.stacks, playerScreenHandler.cursorStack)
         player.networkHandler.sendPacket(inventoryPacket)
     }
+
+    override fun quickMove(player: PlayerEntity, slot: Int): ItemStack {
+        return ItemStack.EMPTY
+    }
+
+    override fun canInsertIntoSlot(slot: Slot): Boolean {
+        return false
+    }
+
+    override fun canUse(player: PlayerEntity): Boolean {
+        return true
+    }
 }

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

@@ -114,6 +114,12 @@ class SlateTest : ModInitializer {
                                 // bounds tests
                                 tiles.setInventory(0, 0, tile(ItemStack(Items.ORANGE_WOOL)))
                                 tiles[tiles.lastIndex] = tile(ItemStack(Items.RED_WOOL))
+
+                                callbacks {
+                                    onInput { _, _, input ->
+                                        println(input)
+                                    }
+                                }
                             }
 
                             subslate.open(context.player)