feat: item-backed container menus (Phase 3)

Archie-Test/common/src/main/gametest/net/kernelpanicsoft/archie/test/gametest/ArchieTestGameTest.kt

@@ -8,6 +8,10 @@ internal fun AEvents.ArchieGameTestBuilder.archieTestGameTests()
 {
 	client {
 		register<TestScreenGameTest>()
+		register<ComposeItemContainerMenuClientTests>()
+	}
+	server {
+		register<ComposeItemContainerMenuTests>()
 	}
 	server {
 		register<DataAttachmentTests>()

Archie-Test/common/src/main/gametest/net/kernelpanicsoft/archie/test/gametest/ComposeItemContainerMenuClientTests.kt

@@ -0,0 +1,70 @@
+package net.kernelpanicsoft.archie.test.gametest
+
+import dev.architectury.registry.menu.MenuRegistry
+import net.kernelpanicsoft.archie.gametest.*
+import net.kernelpanicsoft.archie.gui.item.PlayerInventoryItemAccess
+import net.kernelpanicsoft.archie.test.TestItemContainerScreen
+import net.kernelpanicsoft.archie.test.TestItemMenu
+import net.minecraft.network.chat.Component
+import net.minecraft.world.SimpleMenuProvider
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.Items
+
+/**
+ * End-to-end coverage for [TestItemMenu]'s excluded-slot behavior, opened through the *real*
+ * server-to-client menu flow ([MenuRegistry.openExtendedMenu] + a real [TestItemContainerScreen]
+ * layout pass) - unlike [ComposeItemContainerMenuTests], which constructs [TestItemMenu] directly
+ * and so can't exercise anything depending on
+ * [net.kernelpanicsoft.archie.gui.ComposeContainerMenuBase.updateSlotData] actually having run
+ * (that method unconditionally sends an outbound `SlotData` packet, which throws from a
+ * server-only GameTest since packet registration itself is skipped there - see that class's KDoc).
+ * A client GameTest has both sides' networking registered for real, so this is where that gap is
+ * actually covered.
+ */
+@Suppress("unused")
+class ComposeItemContainerMenuClientTests
+{
+	@ClientGameTest
+	fun ClientGameTestContext.testExcludedSlotBehaviorViaRealMenuOpen()
+	{
+		withWorld {
+			withSingleplayer {
+				waitForPlayer()
+
+				server.runOnServer { minecraftServer ->
+					val player = minecraftServer.playerList.players.first()
+					player.inventory.setItem(0, ItemStack(Items.PAPER))
+					MenuRegistry.openExtendedMenu(
+						player,
+						SimpleMenuProvider(
+							{ id, inv, p -> TestItemMenu(id, inv, PlayerInventoryItemAccess(p, 0, Items.PAPER)) },
+							Component.literal("Test Item Menu"),
+						),
+					) { buf -> buf.writeVarInt(0) }
+				}
+
+				clientContext.waitForScreen<TestItemContainerScreen>()
+				clientContext.waitForComposeIdle()
+				// One extra tick so the client's just-reported SlotData round-trips back through
+				// the server (ComposeContainerMenuBase.updateSlotData -> serverbound SlotData ->
+				// menu.applySlotData()) and the server's own slot list is actually built.
+				clientContext.waitTicks(2)
+
+				server.runOnServer { minecraftServer ->
+					val player = minecraftServer.playerList.players.first()
+					val menu = player.containerMenu as? TestItemMenu
+						?: error("Expected the player's current menu to be a TestItemMenu, was ${player.containerMenu}")
+
+					val excludedSlot = menu.slots.firstOrNull { it.container === player.inventory && it.containerSlot == 0 }
+						?: error("Expected a player-inventory slot bound to container index 0 among ${menu.slots.size} slots")
+					if (excludedSlot.mayPlace(ItemStack(Items.STONE))) fail("Expected the excluded slot to reject placement")
+					if (excludedSlot.mayPickup(player)) fail("Expected the excluded slot to reject pickup")
+
+					val excludedIndex = menu.slots.indexOf(excludedSlot)
+					val result = menu.quickMoveStack(player, excludedIndex)
+					if (!result.isEmpty) fail("Expected quickMoveStack on the excluded slot to return an empty stack, got $result")
+				}
+			}
+		}
+	}
+}

Archie-Test/common/src/main/gametest/net/kernelpanicsoft/archie/test/gametest/ComposeItemContainerMenuTests.kt

@@ -0,0 +1,117 @@
+package net.kernelpanicsoft.archie.test.gametest
+
+import earth.terrarium.common_storage_lib.storage.base.UpdateManager
+import net.kernelpanicsoft.archie.gui.item.PlayerInventoryItemAccess
+import net.kernelpanicsoft.archie.gametest.internal.EMPTY
+import net.kernelpanicsoft.archie.test.TestItemMenu
+import net.minecraft.gametest.framework.GameTest
+import net.minecraft.gametest.framework.GameTestHelper
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.Items
+
+/**
+ * GameTest coverage for [net.kernelpanicsoft.archie.gui.item.ComposeItemContainerMenu], via the
+ * fixture [TestItemMenu] (declared directly against a real
+ * [net.minecraft.gametest.framework.GameTestHelper.makeMockServerPlayerInLevel] player - no
+ * network round trip, matching [net.kernelpanicsoft.archie.test.gametest.CapabilityLookupTests]'s
+ * "construct against real infrastructure directly" style).
+ *
+ * Every test that constructs a [TestItemMenu] here must explicitly call `menu.removed(player)`
+ * once done (unless the test is specifically about the auto-close path) - `onMenuOpened()`
+ * unconditionally registers the menu with the real, process-wide
+ * [net.kernelpanicsoft.archie.gui.item.ItemStateManager], whose real tick listener is genuinely
+ * running for the whole GameTest server process, not just this test method. A menu left
+ * registered keeps getting ticked (and its `itemAccess.stillValid(player)` re-checked) by every
+ * *later* test in this run, not just this one - confirmed the hard way: an earlier draft of this
+ * suite left menus registered, and a later test's `itemAccess.stillValid` flip cascaded into an
+ * unrelated packet-registration crash days after this test method had already returned.
+ *
+ * Not covered here - manual-only, matching the Phase 3 plan's own carve-out for full on-screen
+ * GUI open/close/shift-click flow (real Compose rendering + real player interaction isn't
+ * GameTest-covered anywhere else in this codebase either):
+ * - The excluded player-inventory slot's `mayPlace`/`mayPickup`/`quickMoveStack` behavior - see
+ *   [ComposeItemContainerMenuClientTests] instead, which covers exactly this via a real menu-open
+ *   round trip (this class can't: it needs
+ *   [net.kernelpanicsoft.archie.gui.ComposeContainerMenuBase.updateSlotData] to have run, which
+ *   sends an outbound `SlotData` packet unconditionally, and packet registration itself is
+ *   deliberately skipped for a server-only GameTest run - `Archie.kt`'s own
+ *   `ArchieNetworkChannel.init()` gating, unrelated to this feature).
+ */
+@Suppress("unused")
+class ComposeItemContainerMenuTests
+{
+	@GameTest(template = EMPTY)
+	fun GameTestHelper.testSlotContentPersistsThroughHolder()
+	{
+		val player = makeMockServerPlayerInLevel()
+		player.inventory.setItem(0, ItemStack(Items.PAPER))
+		val menu = TestItemMenu(1, player.inventory, PlayerInventoryItemAccess(player, 0, Items.PAPER))
+
+		menu.items[0].set(ItemStack(Items.DIAMOND, 5))
+		// ArchieItemSlot.set() only mutates in-memory state - persistence is triggered externally,
+		// the same way ArchieItemMenuSlot.setChanged() (a real vanilla Slot's hook) does it.
+		UpdateManager.batch(menu.items)
+
+		// A second, independent menu constructed against the same real backing stack re-loads
+		// fresh from its persisted NBT (ItemStackNBTHolderImpl.init reloads every construction) -
+		// this is a genuine round trip through the public API, not just reading `menu`'s own
+		// still-live in-memory ArchieItemStorage back.
+		val reloaded = TestItemMenu(11, player.inventory, PlayerInventoryItemAccess(player, 0, Items.PAPER))
+		val item = reloaded.items[0].getItem()
+		menu.removed(player)
+		reloaded.removed(player)
+		if (item.item != Items.DIAMOND || item.count != 5)
+			fail("Expected the item written through menu.items to persist onto the real backing stack, got $item")
+		succeed()
+	}
+
+	@GameTest(template = EMPTY)
+	fun GameTestHelper.testStillValidReflectsItemAccess()
+	{
+		val player = makeMockServerPlayerInLevel()
+		player.inventory.setItem(0, ItemStack(Items.PAPER))
+		val menu = TestItemMenu(4, player.inventory, PlayerInventoryItemAccess(player, 0, Items.PAPER))
+
+		val initiallyValid = menu.stillValid(player)
+		player.inventory.setItem(0, ItemStack(Items.STONE))
+		val validAfterCorruption = menu.stillValid(player)
+		menu.removed(player)
+
+		if (!initiallyValid) fail("Expected stillValid to be true while the backing stack still matches")
+		if (validAfterCorruption) fail("Expected stillValid to be false once the backing stack no longer matches")
+		succeed()
+	}
+
+	@GameTest(template = EMPTY)
+	fun GameTestHelper.testSyncedFieldRegistersSerializer()
+	{
+		val player = makeMockServerPlayerInLevel()
+		player.inventory.setItem(0, ItemStack(Items.PAPER))
+		val menu = TestItemMenu(5, player.inventory, PlayerInventoryItemAccess(player, 0, Items.PAPER))
+
+		val registered = menu.itemState.propertySerializers.containsKey("counter")
+		menu.removed(player)
+
+		if (!registered)
+			fail("Expected the @Sync-annotated `counter` field to have registered a serializer in itemState at declaration time")
+		succeed()
+	}
+
+	@GameTest(template = EMPTY)
+	fun GameTestHelper.testItemStateManagerForceClosesInvalidMenu()
+	{
+		val player = makeMockServerPlayerInLevel()
+		player.inventory.setItem(0, ItemStack(Items.PAPER))
+		val menu = TestItemMenu(6, player.inventory, PlayerInventoryItemAccess(player, 0, Items.PAPER))
+		player.containerMenu = menu
+
+		// Corrupt the backing stack so itemAccess.stillValid(player) flips false. No explicit
+		// removed() call here - the whole point of this test is that ItemStateManager's real tick
+		// loop closes (and so unregisters) it on its own.
+		player.inventory.setItem(0, ItemStack(Items.STONE))
+
+		succeedWhen {
+			if (player.containerMenu === menu) fail("Expected ItemStateManager's tick loop to force-close the menu via player.closeContainer() once itemAccess reports it invalid")
+		}
+	}
+}

Archie-Test/common/src/main/kotlin/net/kernelpanicsoft/archie/test/GuiRegistry.kt

@@ -1,12 +1,14 @@
 package net.kernelpanicsoft.archie.test
 
 import net.kernelpanicsoft.archie.Archie
+import net.kernelpanicsoft.archie.gui.item.PlayerInventoryItemAccess
 import net.kernelpanicsoft.archie.registries.ADeferredRegistryHolder
 import dev.architectury.registry.menu.MenuRegistry
 import net.minecraft.core.registries.Registries
 import net.minecraft.network.chat.Component
 import net.minecraft.world.entity.player.Inventory
 import net.minecraft.world.inventory.MenuType
+import net.minecraft.world.item.Items
 
 object GuiRegistry : ADeferredRegistryHolder<MenuType<*>>(Archie.MOD, Registries.MENU)
 {
@@ -20,9 +22,20 @@ object GuiRegistry : ADeferredRegistryHolder<MenuType<*>>(Archie.MOD, Registries
 		}
 	}
 
+	val TestItemMenu: MenuType<TestItemMenu> by register("test_item_menu") {
+		MenuRegistry.ofExtended { id, inventory, buf ->
+			TestItemMenu(
+				id,
+				inventory,
+				PlayerInventoryItemAccess(inventory.player, buf.readVarInt(), Items.PAPER)
+			)
+		}
+	}
+
 	override fun initClient()
 	{
 		MenuRegistry.registerScreenFactory(TestMenu, ::TestScreen)
+		MenuRegistry.registerScreenFactory(TestItemMenu, ::TestItemContainerScreen)
 	}
 
 }

Archie-Test/common/src/main/kotlin/net/kernelpanicsoft/archie/test/TestItemContainerScreen.kt

@@ -0,0 +1,22 @@
+package net.kernelpanicsoft.archie.test
+
+import net.kernelpanicsoft.archie.gui.ComposeContainerScreen
+import net.kernelpanicsoft.archie.gui.PlayerSlots
+import net.kernelpanicsoft.archie.gui.Slots
+import net.kernelpanicsoft.archie.gui.theme.Theme
+import net.minecraft.network.chat.Component
+import net.minecraft.world.entity.player.Inventory
+
+/** Minimal fixture screen for [TestItemMenu] - just enough layout to drive a real [net.kernelpanicsoft.archie.gui.ComposeContainerMenuBase.updateSlotData] round trip. */
+class TestItemContainerScreen(menu: TestItemMenu, playerInventory: Inventory, title: Component) : ComposeContainerScreen<TestItemMenu>(menu, playerInventory, title)
+{
+	init
+	{
+		start {
+			Theme {
+				Slots("inventory", 9, 1)
+				PlayerSlots()
+			}
+		}
+	}
+}

Archie-Test/common/src/main/kotlin/net/kernelpanicsoft/archie/test/TestItemMenu.kt

@@ -0,0 +1,21 @@
+package net.kernelpanicsoft.archie.test
+
+import net.kernelpanicsoft.archie.gui.item.ComposeItemContainerMenu
+import net.kernelpanicsoft.archie.gui.item.ItemContainerAccess
+import net.kernelpanicsoft.archie.serialization.Sync
+import net.minecraft.world.entity.player.Inventory
+
+/** Fixture item-backed menu for [net.kernelpanicsoft.archie.test.gametest.ComposeItemContainerMenuTests]/[net.kernelpanicsoft.archie.test.gametest.ComposeItemContainerMenuClientTests]. */
+class TestItemMenu(id: Int, inventory: Inventory, access: ItemContainerAccess) :
+	ComposeItemContainerMenu<TestItemMenu>(GuiRegistry.TestItemMenu, id, inventory, access)
+{
+	@Sync
+	var counter by holder.intField()
+
+	val items by holder.itemField(9)
+
+	override fun registerSlotHandlers()
+	{
+		handler("inventory", items)
+	}
+}

Archie-Test/common/src/main/kotlin/net/kernelpanicsoft/archie/test/TestMenu.kt

@@ -1,9 +1,9 @@
 package net.kernelpanicsoft.archie.test
 
-import net.kernelpanicsoft.archie.gui.ComposeContainerMenu
+import net.kernelpanicsoft.archie.gui.ComposeBlockContainerMenu
 import net.minecraft.world.entity.player.Inventory
 
-class TestMenu(id: Int, inventory: Inventory, tile: TestTile) : ComposeContainerMenu<TestTile, TestMenu>(GuiRegistry.TestMenu, id, inventory, tile)
+class TestMenu(id: Int, inventory: Inventory, tile: TestTile) : ComposeBlockContainerMenu<TestTile, TestMenu>(GuiRegistry.TestMenu, id, inventory, tile)
 {
 	val rows: Int = tile.items.size() / 9
 

Archie-Test/common/src/main/kotlin/net/kernelpanicsoft/archie/test/TestScreen.kt

@@ -43,7 +43,7 @@ import net.kernelpanicsoft.archie.gui.util.KColor
 import net.minecraft.network.chat.Component
 import net.minecraft.world.entity.player.Inventory
 
-class TestScreen(menu: TestMenu, playerInventory: Inventory, title: Component) : ComposeContainerScreen<TestMenu, TestTile>(menu, playerInventory,
+class TestScreen(menu: TestMenu, playerInventory: Inventory, title: Component) : ComposeContainerScreen<TestMenu>(menu, playerInventory,
 	title
 )
 {

Archie-Test/neoforge/src/main/kotlin/net/kernelpanicsoft/archie/test/ArchieTestNeoForge.kt

@@ -5,7 +5,6 @@ import net.neoforged.fml.common.Mod
 import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent
 import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent
 import net.neoforged.fml.event.lifecycle.FMLConstructModEvent
-import net.neoforged.neoforge.client.event.RegisterMenuScreensEvent
 
 @Mod(ArchieTest.MOD_ID)
 object ArchieTestNeoForge
@@ -20,8 +19,10 @@ object ArchieTestNeoForge
 		MOD_BUS.addListener<FMLCommonSetupEvent> {
 			ArchieTest.initCommon()
 		}
-		MOD_BUS.addListener<RegisterMenuScreensEvent> {
-			it.register(GuiRegistry.TestMenu, ::TestScreen)
-		}
+		// GuiRegistry.initClient() (an ADeferredRegistryHolder override) now registers its own
+		// screen factories at the correct time on its own - see
+		// net.kernelpanicsoft.archie.registries.scheduleEarlyClientRegistration. A manual
+		// RegisterMenuScreensEvent listener duplicating that here would now throw
+		// "Duplicate attempt to register screen" instead of silently doing nothing.
 	}
 }

Archie/common/build.gradle.kts

@@ -125,8 +125,16 @@ tasks {
 		dependsOn(verifyGuiSpriteAssets)
 	}
 
+	// Keep stubUnfulfilledExpects()'s generated throwing-actual stubs out of what gets published -
+	// a consumer with both this jar and a real actual on its classpath must only ever see the
+	// real one, or Kotlin's actual-resolution can end up preferring the stub.
 	jar {
 		from(sourceSets.main.get().output)
+		exclude("**/*StubKt.class")
+	}
+
+	sourcesJar {
+		exclude("**/*Stub.kt")
 	}
 
 	test {

Archie/common/src/main/kotlin/net/kernelpanicsoft/archie/Archie.kt

@@ -21,6 +21,7 @@ import net.kernelpanicsoft.archie.gametest.AGameTestSide
 import net.kernelpanicsoft.archie.gametest.ThreadingImpl
 import net.kernelpanicsoft.archie.gametest.internal.ArchieGameTest
 import net.kernelpanicsoft.archie.gui.blockentity.BlockEntityStateManager
+import net.kernelpanicsoft.archie.gui.item.ItemStateManager
 import net.kernelpanicsoft.archie.gui.theme.ThemeManifestResourceListener
 import net.kernelpanicsoft.archie.gui.theme.ThemeResourceListener
 import net.kernelpanicsoft.archie.networking.ArchieNetworkChannel
@@ -74,6 +75,7 @@ object Archie
 			ArchieNetworkChannel.init()
 		}
 		BlockEntityStateManager.init()
+		ItemStateManager.init()
 
 		ABuiltinIngredients.init()
 		ABuiltinConditions.init()