init request handler structure rewrite

Author: beanbag44

common/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -32,7 +32,7 @@ class BreakSettings(
     override val breakThreshold by c.setting("Break Threshold", 0.7f, 0.1f..1.0f, 0.02f, "The break amount at which the block is considered broken") { vis() }
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once") { vis() }
     override val breakDelay by c.setting("Break Delay", 0, 0..5, 1, "The delay between breaking blocks", " ticks") { vis() }
-    override val sequenceMode by c.setting("Break Sequence Mode", BuildConfig.InteractSequenceMode.PostMovement, "The sub-tick timing at which break actions are performed", vis)
+    override val breakStageMask by c.setting("Break Stage Mask", setOf(*TickStage.entries.toTypedArray()), "The sub-tick timing at which break actions can be performed", vis)
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() }
     override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing != SwingMode.None }
     override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds") { vis() }
@@ -42,7 +42,7 @@ class BreakSettings(
     override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken") { vis() }
     override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking") { vis() }
     override val maxPendingBreaks by c.setting("Max Pending Breaks", 15, 1..30, 1, "The maximum amount of pending breaks") { vis() }
-    override val instantBreaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() }
+    override val breaksPerTick by c.setting("Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() }
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() }
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() }
     override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { vis() }

common/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt

@@ -26,20 +26,14 @@ interface BuildConfig {
     val interactionTimeout: Int
 
     // Breaking
-    val breakSettings: BreakSettings
+    val breaking: BreakSettings
 
     // Placing
-    val placeSettings: PlaceSettings
+    val placing: PlaceSettings
 
     enum class SwingType {
         Vanilla,
         Server,
         Client
     }
-
-    enum class InteractSequenceMode {
-        TickStart,
-        Vanilla,
-        PostMovement,
-    }
 }

common/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt

@@ -38,10 +38,10 @@ class BuildSettings(
     override val maxPendingInteractions by c.setting("Max Pending Interactions", 20, 1..30, 1, "Dont wait for this many interactions for the server response") { vis() && page == Page.General }
 
     // Breaking
-    override val breakSettings = BreakSettings(c) { page == Page.Break && vis() }
+    override val breaking = BreakSettings(c) { page == Page.Break && vis() }
 
     // Placing
-    override val placeSettings = PlaceSettings(c) { page == Page.Place && vis() }
+    override val placing = PlaceSettings(c) { page == Page.Place && vis() }
 
-    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") { vis() && ((page == Page.Place && placeSettings.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None) || (page == Page.Break && breakSettings.breakConfirmation != BreakConfirmationMode.None)) }
+    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") { vis() && ((page == Page.Place && placing.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None) || (page == Page.Break && breaking.breakConfirmation != BreakConfirmationMode.None)) }
 }

common/src/main/kotlin/com/lambda/config/groups/HotbarSettings.kt

@@ -29,5 +29,6 @@ class HotbarSettings(
     override val keepTicks by c.setting("Keep Ticks", 3, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", vis)
     override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks", vis)
     override val swapsPerTick by c.setting("Swaps Per Tick", 3, 1..10, 1, "The number of hotbar selection swaps that can take place each tick") { swapDelay <= 0 && vis() }
-    override var swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis)
+    override val swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis)
+    override val sequenceStageMask by c.setting("Hotbar Stage Mask", setOf(*TickStage.entries.toTypedArray()), "The sub-tick timing at which hotbar actions are performed", vis)
 }

common/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt

@@ -29,7 +29,7 @@ class PlaceSettings(
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() }
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces") { vis() }
     override val axisRotateSetting by c.setting("Axis Rotate", true, "Overrides the Rotate For Place setting and rotates the player on each axis to air place rotational blocks") { vis() && airPlace.isEnabled() }
-    override val sequenceMode by c.setting("Place Sequence Mode", BuildConfig.InteractSequenceMode.PostMovement, "The sub-tick timing at which break actions are performed") { vis() }
+    override val placeStageMask by c.setting("Place Sequence Mode", setOf(*TickStage.entries.toTypedArray()), "The sub-tick timing at which break actions are performed") { vis() }
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation") { vis() }
     override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements") { vis() }
     override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }

common/src/main/kotlin/com/lambda/config/groups/TickStage.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.config.groups
+
+enum class TickStage {
+    TickStart,
+    PostHotbar,
+    PostInteract,
+    PreMovement,
+    PostMovement,
+}

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

@@ -20,23 +20,8 @@ package com.lambda.event.events
 import com.lambda.event.Event
 
 sealed class UpdateManagerEvent {
-    sealed class Rotation {
-        class Pre : Event
-        class Post : Event
-    }
-
-    sealed class Hotbar {
-        class Pre : Event
-        class Post : Event
-    }
-
-    sealed class Break {
-        class Pre : Event
-        class Post : Event
-    }
-
-    sealed class Place {
-        class Pre : Event
-        class Post : Event
-    }
+    class Rotation : Event
+    class Hotbar : Event
+    class Break : Event
+    class Place : Event
 }

common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt

@@ -22,6 +22,8 @@ import com.lambda.context.SafeContext
 import com.lambda.graphics.renderer.esp.DirectionMask
 import com.lambda.graphics.renderer.esp.DirectionMask.exclude
 import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.interaction.request.breaking.BreakRequest
+import com.lambda.interaction.request.hotbar.HotbarRequest
 import com.lambda.interaction.request.rotation.RotationRequest
 import com.lambda.util.world.raycast.RayCastUtils.distanceTo
 import net.minecraft.block.BlockState
@@ -70,10 +72,15 @@ data class BreakContext(
         }
     }
 
-    override fun shouldRotate(config: BuildConfig) = config.breakSettings.rotateForBreak
+    override fun shouldRotate(config: BuildConfig) = config.breaking.rotateForBreak
 
     override fun SafeContext.buildRenderer() {
         withState(checkedState, expectedPos, baseColor, DirectionMask.ALL.exclude(result.side))
         withState(checkedState, expectedPos, sideColor, result.side)
     }
+
+    fun requestDependencies(request: BreakRequest): Boolean {
+        val hotbarRequest = request.hotbar.request(HotbarRequest(hotbarIndex, request.hotbar))
+        return hotbarRequest.done
+    }
 }

common/src/main/kotlin/com/lambda/interaction/construction/context/PlaceContext.kt

@@ -22,6 +22,8 @@ import com.lambda.context.SafeContext
 import com.lambda.graphics.renderer.esp.DirectionMask
 import com.lambda.graphics.renderer.esp.DirectionMask.exclude
 import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.interaction.request.hotbar.HotbarRequest
+import com.lambda.interaction.request.placing.PlaceRequest
 import com.lambda.interaction.request.rotation.RotationRequest
 import com.lambda.util.BlockUtils
 import com.lambda.util.BlockUtils.blockState
@@ -73,5 +75,11 @@ data class PlaceContext(
         withState(blockState(result.blockPos), result.blockPos, sideColor, result.side)
     }
 
-    override fun shouldRotate(config: BuildConfig) = config.placeSettings.rotateForPlace
+    override fun shouldRotate(config: BuildConfig) = config.placing.rotate
+
+    fun requestDependencies(request: PlaceRequest): Boolean {
+        val hotbarRequest = request.hotbar.request(HotbarRequest(hotbarIndex, request.hotbar))
+        val validRotation = if (request.build.placing.rotate) request.rotation.request(rotation).done else true
+        return hotbarRequest.done && validRotation
+    }
 }

common/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt

@@ -92,11 +92,11 @@ object BuildSimulator {
             checkRequirements(pos, target, build)?.let {
                 return@flatMap setOf(it)
             }
-            checkPlaceResults(pos, target, eye, build.placeSettings, interact, rotation, inventory).let {
+            checkPlaceResults(pos, target, eye, build.placing, interact, rotation, inventory).let {
                 if (it.isEmpty()) return@let
                 return@flatMap it
             }
-            checkBreakResults(pos, eye, build.placeSettings, interact, rotation, inventory, build).let {
+            checkBreakResults(pos, eye, build.placing, interact, rotation, inventory, build).let {
                 if (it.isEmpty()) return@let
                 return@flatMap it
             }
@@ -122,7 +122,7 @@ object BuildSimulator {
         }
 
         /* block should be ignored */
-        if (state.block in build.breakSettings.ignoredBlocks && target.type == TargetState.Type.AIR) {
+        if (state.block in build.breaking.ignoredBlocks && target.type == TargetState.Type.AIR) {
             return BuildResult.Ignored(pos)
         }
 
@@ -392,7 +392,7 @@ object BuildSimulator {
         val state = blockState(pos)
 
         /* is a block that will be destroyed by breaking adjacent blocks */
-        if (build.breakSettings.breakWeakBlocks && state.block.hardness == 0f && !state.isAir) {
+        if (build.breaking.breakWeakBlocks && state.block.hardness == 0f && !state.isAir) {
             acc.add(BuildResult.Ignored(pos))
             return acc
         }
@@ -465,7 +465,7 @@ object BuildSimulator {
                     state,
                     targetState,
                     player.inventory.selectedSlot,
-                    instantBreakable(state, pos, build.breakSettings.breakThreshold)
+                    instantBreakable(state, pos, build.breaking.breakThreshold)
                 )
                 acc.add(BreakResult.Break(pos, breakContext))
                 return acc
@@ -510,7 +510,7 @@ object BuildSimulator {
         val blockHit = bestHit.hit.blockResult ?: return acc
         val target = lookAt(bestHit.targetRotation, 0.001)
         val request = RotationRequest(target, rotation)
-        val instant = instantBreakable(state, pos, build.breakSettings.breakThreshold)
+        val instant = instantBreakable(state, pos, build.breaking.breakThreshold)
 
         val breakContext = BreakContext(
             eye, blockHit, request, state, targetState, player.inventory.selectedSlot, instant
@@ -538,10 +538,10 @@ object BuildSimulator {
             return acc
         }
 
-        val toolSelection = if (build.breakSettings.forceSilkTouch) {
+        val toolSelection = if (build.breaking.forceSilkTouch) {
             selectStack { isOneOfItems(bestTools) and hasEnchantment(Enchantments.SILK_TOUCH) }
-        } else if (build.breakSettings.forceFortunePickaxe) {
-            selectStack { isOneOfItems(bestTools) and hasEnchantment(Enchantments.FORTUNE, build.breakSettings.minFortuneLevel) }
+        } else if (build.breaking.forceFortunePickaxe) {
+            selectStack { isOneOfItems(bestTools) and hasEnchantment(Enchantments.FORTUNE, build.breaking.minFortuneLevel) }
         } else {
             bestTools.select()
         }
@@ -568,7 +568,7 @@ object BuildSimulator {
         if (toolPair == null) return acc
 
         breakContext.hotbarIndex = player.hotbar.indexOf(toolPair.first)
-        breakContext.instantBreak = instantBreakable(state, pos, toolPair.first, build.breakSettings.breakThreshold)
+        breakContext.instantBreak = instantBreakable(state, pos, toolPair.first, build.breaking.breakThreshold)
 	    acc.add(BreakResult.Break(pos, breakContext))
         return acc
     }