RequestConfig refactor and submitting from the request itself rather than the configs as theyre not coupled outside the request anymore

Author: beanbag44

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

@@ -20,13 +20,18 @@ package com.lambda.config.groups
 import com.lambda.config.Configurable
 import com.lambda.event.events.TickEvent
 import com.lambda.interaction.request.breaking.BreakConfig
+import com.lambda.interaction.request.breaking.BreakConfig.AnimationMode
+import com.lambda.interaction.request.breaking.BreakConfig.BreakConfirmationMode
+import com.lambda.interaction.request.breaking.BreakConfig.BreakMode
+import com.lambda.interaction.request.breaking.BreakConfig.SortMode
+import com.lambda.interaction.request.breaking.BreakConfig.SwingMode
 import com.lambda.util.BlockUtils.allSigns
 import java.awt.Color
 
 class BreakSettings(
     c: Configurable,
     vis: () -> Boolean = { true }
-) : BreakConfig() {
+) : BreakConfig {
     val page by c.setting("Break Page", Page.General, visibility = vis)
     override val breakMode by c.setting("Break Mode", BreakMode.Packet) { vis() && page == Page.General }
     override val sorter by c.setting("Sorter", SortMode.Closest, "The order in which breaks are performed") { vis() && page == Page.General }

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

@@ -24,7 +24,7 @@ import com.lambda.interaction.request.hotbar.HotbarConfig
 class HotbarSettings(
     c: Configurable,
     vis: () -> Boolean = { true }
-) : HotbarConfig() {
+) : HotbarConfig {
     override val keepTicks by c.setting("Keep Ticks", 3, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", visibility = 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", visibility = 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() }

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

@@ -18,11 +18,12 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
+import com.lambda.interaction.request.interacting.InteractConfig
 
 class InteractSettings(
     c: Configurable,
     vis: () -> Boolean =  { true }
-) : InteractConfig() {
+) : InteractConfig {
     override val rotate by c.setting("Rotate For Interact", true, "Rotates the player to look at the block when interacting", visibility = vis)
     override val swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting", visibility = vis)
     override val interactSwingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swingHand }

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

@@ -17,54 +17,47 @@
 
 package com.lambda.config.groups
 
-import com.lambda.interaction.request.RequestConfig
-import com.lambda.interaction.request.interacting.InteractionManager
-import com.lambda.interaction.request.interacting.InteractionRequest
 import com.lambda.interaction.request.rotating.visibilty.PointSelection
 
-abstract class InteractionConfig : RequestConfig<InteractionRequest>() {
+interface InteractionConfig {
     /**
      * Maximum entity interaction distance
      */
-    abstract val attackReach: Double
+    val attackReach: Double
 
     /**
      * Maximum block interaction distance
      */
-    abstract val interactReach: Double
+    val interactReach: Double
 
     /**
      * Maximum possible interaction distance
      *
      * Equals to `max(attackReach, placeReach)` if both are present. Equals to one of them otherwise
      */
-    abstract val scanReach: Double
+    val scanReach: Double
 
     /**
      * Whether to include the environment to the ray cast context.
      *
      * if false: skips walls for entities, skips entities for blocks.
      */
-    abstract val strictRayCast: Boolean
+    val strictRayCast: Boolean
 
     /**
      * Whether to check if an AABB side is visible.
      */
-    abstract val checkSideVisibility: Boolean
+    val checkSideVisibility: Boolean
 
     /**
      * Grid divisions count per surface of the hit box.
      */
-    abstract val resolution: Int
+    val resolution: Int
 
     /**
      * The way to select the best point.
      */
-    abstract val pointSelection: PointSelection
-
-    override fun requestInternal(request: InteractionRequest, queueIfClosed: Boolean) {
-        InteractionManager.request(request, queueIfClosed)
-    }
+    val pointSelection: PointSelection
 
     enum class InteractConfirmationMode {
         None,

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

@@ -26,7 +26,7 @@ class InteractionSettings(
     c: Configurable,
     private val usage: InteractionMask,
     vis: () -> Boolean = { true },
-) : InteractionConfig() {
+) : InteractionConfig {
     // Reach
     private val useDefaultReach by c.setting("Default Reach", true, "Whether to use vanilla interaction ranges", visibility = vis)
     private val attackReachSetting = if (usage.entity) c.setting("Attack Reach", DEFAULT_ATTACK_REACH, 1.0..10.0, 0.01, "Maximum entity interaction distance") { vis() && !useDefaultReach } else null
@@ -40,7 +40,7 @@ class InteractionSettings(
         return if (useDefaultReach) DEFAULT_ATTACK_REACH else attackReachSetting!!.value
     }
 
-    override val interactReach: Double get()  {
+    override val interactReach: Double get() {
         check(usage.block) {
             "Given interaction config has no place reach implementation"
         }

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

@@ -18,12 +18,14 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
+import com.lambda.interaction.request.inventory.InventoryConfig
+import com.lambda.interaction.request.inventory.InventoryConfig.Priority
 import com.lambda.util.item.ItemUtils
 
 class InventorySettings(
     c: Configurable,
-    vis: () -> Boolean = { true },
-) : InventoryConfig() {
+    vis: () -> Boolean = { true }
+) : InventoryConfig {
     val page by c.setting("Inventory Page", Page.Container, "The page to open when the module is enabled", vis)
 
     override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, "Items that will be included when checking for a free slot / are allowed to be droped when inventory is full") { vis() && page == Page.Container}

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

@@ -20,11 +20,13 @@ package com.lambda.config.groups
 import com.lambda.config.Configurable
 import com.lambda.event.events.TickEvent
 import com.lambda.interaction.request.placing.PlaceConfig
+import com.lambda.interaction.request.placing.PlaceConfig.AirPlaceMode
+import com.lambda.interaction.request.placing.PlaceConfig.PlaceConfirmationMode
 
 class PlaceSettings(
     c: Configurable,
     vis: () -> Boolean = { true }
-) : PlaceConfig() {
+) : PlaceConfig {
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing", visibility = vis)
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces", visibility = 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() }

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

@@ -30,7 +30,7 @@ import kotlin.random.Random
 class RotationSettings(
     c: Configurable,
     vis: () -> Boolean = { true }
-) : RotationConfig() {
+) : RotationConfig {
     override var rotationMode by c.setting("Mode", RotationMode.Sync, "SILENT - server-side rotation, SYNC - server-side rotation; client-side movement, LOCK - Lock camera, NONE - No rotation", visibility = vis)
 
     /** How many ticks to keep the rotation before resetting */
@@ -66,4 +66,4 @@ class RotationSettings(
 
         return sqrt(-2.0 * ln(u1)) * cos(2.0 * PI * u2)
     }
-}
+}

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

@@ -76,8 +76,10 @@ data class BreakContext(
         withState(cachedState, blockPos, sideColor, result.side)
     }
 
-    fun requestDependencies(breakRequest: BreakRequest, minKeepTicks: Int = 0): Boolean {
-        val request = HotbarRequest(hotbarIndex, breakRequest.hotbar, breakRequest.hotbar.keepTicks.coerceAtLeast(minKeepTicks))
-        return request.config.request(request, false).done
-    }
-}
+    fun requestDependencies(breakRequest: BreakRequest, minKeepTicks: Int = 0): Boolean =
+        HotbarRequest(
+            hotbarIndex,
+            breakRequest.hotbar,
+            breakRequest.hotbar.keepTicks.coerceAtLeast(minKeepTicks)
+        ).submit(false).done
+}

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

@@ -22,7 +22,7 @@ import com.lambda.graphics.renderer.esp.DirectionMask
 import com.lambda.graphics.renderer.esp.DirectionMask.exclude
 import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.hotbar.HotbarRequest
-import com.lambda.interaction.request.interacting.InteractionRequest
+import com.lambda.interaction.request.interacting.InteractRequest
 import com.lambda.interaction.request.rotating.RotationRequest
 import com.lambda.util.BlockUtils
 import com.lambda.util.BlockUtils.blockState
@@ -65,11 +65,9 @@ class InteractionContext(
         withState(blockState(result.blockPos), result.blockPos, sideColor, result.side)
     }
 
-    fun requestDependencies(request: InteractionRequest): Boolean {
-        val hotbarRequest = request.hotbar.request(HotbarRequest(hotbarIndex, request.hotbar), false)
-        val validRotation = if (request.config.rotate) {
-            request.rotation.request(rotation, false).done
-        } else true
+    fun requestDependencies(request: InteractRequest): Boolean {
+        val hotbarRequest = HotbarRequest(hotbarIndex, request.hotbar).submit(false)
+        val validRotation = if (request.rotate) rotation.submit(false).done else true
         return hotbarRequest.done && validRotation
     }
 }