Clean up InventoryEvents

Author: Avanatiker

common/src/main/java/com/lambda/mixin/MinecraftClientMixin.java

@@ -20,7 +20,7 @@
 import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.ClientEvent;
-import com.lambda.event.events.ScreenHandlerEvent;
+import com.lambda.event.events.InventoryEvent;
 import com.lambda.event.events.TickEvent;
 import com.lambda.module.modules.player.Interact;
 import net.minecraft.client.MinecraftClient;
@@ -78,7 +78,7 @@ private void onStartup(CallbackInfo ci) {
     private void onScreenOpen(@Nullable Screen screen, CallbackInfo ci) {
         if (screen == null) return;
         if (screen instanceof ScreenHandlerProvider<?> handledScreen) {
-            EventFlow.post(new ScreenHandlerEvent.Open(handledScreen.getScreenHandler()));
+            EventFlow.post(new InventoryEvent.Open(handledScreen.getScreenHandler()));
         }
     }
 

common/src/main/java/com/lambda/mixin/network/ClientPlayNetworkHandlerMixin.java

@@ -31,7 +31,7 @@
 public class ClientPlayNetworkHandlerMixin {
     @Inject(method = "onUpdateSelectedSlot", at = @At(value = "TAIL"))
     private void onUpdateSelectedSlot(UpdateSelectedSlotS2CPacket packet, CallbackInfo ci) {
-        EventFlow.post(new InventoryEvent.SelectedSlotUpdate(packet.getSlot()));
+        EventFlow.post(new InventoryEvent.SelectedHotbarSlotUpdate(packet.getSlot()));
     }
 
     @Inject(method = "onScreenHandlerSlotUpdate", at = @At(value = "TAIL"))

common/src/main/java/com/lambda/mixin/render/ScreenHandlerMixin.java

@@ -18,7 +18,7 @@
 package com.lambda.mixin.render;
 
 import com.lambda.event.EventFlow;
-import com.lambda.event.events.ScreenHandlerEvent;
+import com.lambda.event.events.InventoryEvent;
 import net.minecraft.item.ItemStack;
 import net.minecraft.screen.ScreenHandler;
 import org.spongepowered.asm.mixin.Mixin;
@@ -32,6 +32,6 @@
 public class ScreenHandlerMixin {
     @Inject(method = "updateSlotStacks", at = @At("TAIL"))
     private void onUpdateSlotStacksHead(int revision, List<ItemStack> stacks, ItemStack cursorStack, CallbackInfo ci) {
-        EventFlow.post(new ScreenHandlerEvent.Update(revision, stacks, cursorStack));
+        EventFlow.post(new InventoryEvent.FullUpdate(revision, stacks, cursorStack));
     }
 }

common/src/main/kotlin/com/lambda/event/events/InventoryEvent.kt

@@ -19,8 +19,71 @@ package com.lambda.event.events
 
 import com.lambda.event.Event
 import net.minecraft.item.ItemStack
+import net.minecraft.screen.ScreenHandler
 
+/**
+ * Represents various events related to inventory interactions, updates, and state changes.
+ *
+ * This sealed class encompasses different types of inventory events that occur during gameplay,
+ * such as opening or closing an inventory, updating inventory contents, or changing hotbar slots.
+ * Each event provides specific contextual data relevant to the inventory interaction.
+ */
 sealed class InventoryEvent {
-    class SelectedSlotUpdate(val slot: Int) : Event
-    class SlotUpdate(val syncId: Int, val revision: Int, val slot: Int, val stack: ItemStack) : Event
+    /**
+     * Represents an event triggered when an inventory or screen is opened.
+     *
+     * This event provides access to the associated [ScreenHandler], which manages the interaction
+     * logic between the inventory and the player. It is typically used to initialize or handle
+     * logic when the screen linked to a player's inventory is opened.
+     *
+     * @property screenHandler The screen handler associated with the opened inventory.
+     */
+    class Open(val screenHandler: ScreenHandler) : Event
+
+    /**
+     * Represents an event triggered when an inventory or screen is closed.
+     *
+     * This event provides access to the associated [ScreenHandler], which manages the interaction
+     * logic between the inventory and the player. It is typically used to finalize or clean up logic
+     * when a player's inventory screen is closed.
+     *
+     * @property screenHandler The screen handler associated with the closed inventory.
+     */
+    class Close(val screenHandler: ScreenHandler) : Event
+
+    /**
+     * Represents an update event for an inventory, typically triggered when inventory contents or states
+     * change during gameplay.
+     *
+     * @property revision The revision number indicating the current state of the inventory.
+     * @property stacks A list of item stacks representing the contents of the inventory slots.
+     * @property cursorStack The item stack currently held by the cursor.
+     */
+    data class FullUpdate(
+        val revision: Int,
+        val stacks: List<ItemStack>,
+        val cursorStack: ItemStack,
+    ) : Event
+
+    /**
+     * Represents an event triggered when a specific inventory slot is updated.
+     *
+     * @property syncId The synchronization ID related to the container or inventory.
+     * @property revision The revision number representing the state of the inventory.
+     * @property slot The index of the updated inventory slot.
+     * @property stack The new item stack in the updated slot.
+     */
+    class SlotUpdate(
+        val syncId: Int,
+        val revision: Int,
+        val slot: Int,
+        val stack: ItemStack
+    ) : Event
+
+    /**
+     * Represents an event triggered when a player switches their selected hotbar slot.
+     *
+     * @property slot The index of the newly selected hotbar slot.
+     */
+    class SelectedHotbarSlotUpdate(val slot: Int) : Event
 }

common/src/main/kotlin/com/lambda/event/events/ScreenHandlerEvent.kt

@@ -18,8 +18,8 @@
 package com.lambda.interaction.material.container
 
 import com.lambda.core.Loadable
+import com.lambda.event.events.InventoryEvent
 import com.lambda.event.events.PlayerEvent
-import com.lambda.event.events.ScreenHandlerEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.material.StackSelection
 import com.lambda.interaction.material.StackSelection.Companion.select
@@ -58,7 +58,7 @@ object ContainerManager : Loadable {
             lastInteractedBlockEntity = it.blockHitResult.blockPos.blockEntity(world)
         }
 
-        listen<ScreenHandlerEvent.Close> { event ->
+        listen<InventoryEvent.Close> { event ->
             if (event.screenHandler !is GenericContainerScreenHandler) return@listen
 
             val handler = event.screenHandler

common/src/main/kotlin/com/lambda/interaction/material/container/ContainerManager.kt

@@ -36,7 +36,7 @@ class PickFromInventoryTransaction @Ta5kBuilder constructor(
             confirming = true
         }
 
-        listen<InventoryEvent.SelectedSlotUpdate> {
+        listen<InventoryEvent.SelectedHotbarSlotUpdate> {
             finish()
         }
     }

common/src/main/kotlin/com/lambda/interaction/material/transfer/transaction/PickFromInventoryTransaction.kt

@@ -18,15 +18,13 @@
 package com.lambda.module.modules.debug
 
 import com.lambda.Lambda.LOG
+import com.lambda.event.events.InventoryEvent
 import com.lambda.event.events.PacketEvent
-import com.lambda.event.events.ScreenHandlerEvent
-import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.Communication.info
 import com.lambda.util.DynamicReflectionSerializer.dynamicString
-import net.minecraft.entity.player.PlayerInventory
 import net.minecraft.network.packet.c2s.play.*
 import net.minecraft.network.packet.s2c.play.InventoryS2CPacket
 import net.minecraft.network.packet.s2c.play.UpdateSelectedSlotS2CPacket
@@ -37,19 +35,19 @@ object InventoryDebug : Module(
     defaultTags = setOf(ModuleTag.DEBUG)
 ) {
     init {
-        listen<ScreenHandlerEvent.Open> { event ->
+        listen<InventoryEvent.Open> { event ->
             info("Opened screen handler: ${event.screenHandler::class.simpleName}")
 
             LOG.info("\n" + event.screenHandler.slots.joinToString("\n") {
                 "${it.inventory::class.simpleName} ${it.index} ${it.x} ${it.y}"
             })
         }
 
-        listen<ScreenHandlerEvent.Close> {
+        listen<InventoryEvent.Close> {
             info("Closed screen handler: ${it.screenHandler::class.simpleName}")
         }
 
-        listen<ScreenHandlerEvent.Update> {
+        listen<InventoryEvent.FullUpdate> {
             info("Updated screen handler: ${it.revision}, ${it.stacks}, ${it.cursorStack}")
         }
 

common/src/main/kotlin/com/lambda/module/modules/debug/InventoryDebug.kt

@@ -18,8 +18,8 @@
 package com.lambda.module.modules.player
 
 import com.lambda.context.SafeContext
+import com.lambda.event.events.InventoryEvent
 import com.lambda.event.events.PlayerEvent
-import com.lambda.event.events.ScreenHandlerEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
@@ -68,7 +68,7 @@ object InventoryTweaks : Module(
             }.run()
         }
 
-        listen<ScreenHandlerEvent.Close> { event ->
+        listen<InventoryEvent.Close> { event ->
             if (event.screenHandler != lastOpenScreen) return@listen
             lastOpenScreen = null
             placedPos?.let {

common/src/main/kotlin/com/lambda/module/modules/player/InventoryTweaks.kt

@@ -19,8 +19,8 @@ package com.lambda.task.tasks
 
 import com.lambda.config.groups.RotationConfig
 import com.lambda.config.groups.InteractionConfig
+import com.lambda.event.events.InventoryEvent
 import com.lambda.event.events.RotationEvent
-import com.lambda.event.events.ScreenHandlerEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.visibilty.VisibilityChecker.lookAtBlock
 import com.lambda.module.modules.client.TaskFlowModule
@@ -56,7 +56,7 @@ class OpenContainer @Ta5kBuilder constructor(
     }
 
     init {
-        listen<ScreenHandlerEvent.Open> {
+        listen<InventoryEvent.Open> {
             if (state != State.OPENING) return@listen
 
             screenHandler = it.screenHandler
@@ -65,14 +65,14 @@ class OpenContainer @Ta5kBuilder constructor(
             if (!waitForSlotLoad) success(it.screenHandler)
         }
 
-        listen<ScreenHandlerEvent.Close> {
+        listen<InventoryEvent.Close> {
             if (screenHandler != it.screenHandler) return@listen
 
             state = State.SCOPING
             screenHandler = null
         }
 
-        listen<ScreenHandlerEvent.Update> {
+        listen<InventoryEvent.FullUpdate> {
             if (state != State.SLOT_LOADING) return@listen
 
             screenHandler?.let {