merge interaction config into build config and denest break, place, and interact settings

Author: beanbag44

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

@@ -17,6 +17,7 @@
 
 package com.lambda.config.groups
 
+import com.lambda.interaction.request.rotating.visibilty.PointSelection
 import com.lambda.util.Describable
 import com.lambda.util.NamedEnum
 
@@ -29,14 +30,15 @@ interface BuildConfig {
     val maxPendingInteractions: Int
     val interactionTimeout: Int
 
-    // Breaking
-    val breakConfig: BreakSettings
+    val useDefaultReach: Boolean
+    val attackReach: Double
+    val interactReach: Double
+    val scanReach: Double
 
-    // Placing
-    val placeConfig: PlaceSettings
-
-    // Interacting
-    val interactConfig: InteractSettings
+    val strictRayCast: Boolean
+    val checkSideVisibility: Boolean
+    val resolution: Int
+    val pointSelection: PointSelection
 
     enum class SwingType(
         override val displayName: String,

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

@@ -18,41 +18,43 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
-import com.lambda.interaction.request.breaking.BreakConfig.BreakConfirmationMode
-import com.lambda.interaction.request.placing.PlaceConfig
+import com.lambda.interaction.request.rotating.visibilty.PointSelection
 import com.lambda.util.NamedEnum
+import kotlin.math.max
 
 class BuildSettings(
     c: Configurable,
-    vararg groupPath: NamedEnum,
+    vararg baseGroup: NamedEnum,
     vis: () -> Boolean = { true },
 ) : BuildConfig, SettingGroup(c, c.settings.size) {
     enum class Group(override val displayName: String) : NamedEnum {
         General("General"),
-        Break("Break"),
-        Place("Place"),
-        Interact("Interact")
+        Reach("Reach"),
+        Scan("Scan")
     }
 
     // General
-    override val pathing by c.setting("Pathing", true, "Path to blocks", vis).group(*groupPath, Group.General)
-    override val stayInRange by c.setting("Stay In Range", true, "Stay in range of blocks", vis).group(*groupPath, Group.General)
-    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks", vis).group(*groupPath, Group.General)
-    override val interactionsPerTick by c.setting("Interactions Per Tick", 5, 1..30, 1, "The amount of interactions that can happen per tick", visibility = vis).group(*groupPath, Group.General)
-    override val maxPendingInteractions by c.setting("Max Pending Interactions", 15, 1..30, 1, "The maximum count of pending interactions to allow before pausing future interactions", visibility = vis).group(*groupPath, Group.General)
-
-    // Breaking
-    override val breakConfig = BreakSettings(c, groupPath.toList() + Group.Break, vis)
-
-    // Placing
-    override val placeConfig = PlaceSettings(c, groupPath.toList() + Group.Place, vis)
-
-    //Interacting
-    override val interactConfig = InteractSettings(c, groupPath.toList() + Group.Interact, vis)
-
-    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") {
-        vis() && (placeConfig.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None
-                || breakConfig.breakConfirmation != BreakConfirmationMode.None
-                || interactConfig.interactConfirmationMode != InteractionConfig.InteractConfirmationMode.None)
-    }.group(*groupPath, Group.Break, BreakSettings.Group.General).group(*groupPath, Group.Place).group(*groupPath, Group.Interact)
+    override val pathing by c.setting("Pathing", true, "Path to blocks", vis).group(*baseGroup, Group.General)
+    override val stayInRange by c.setting("Stay In Range", true, "Stay in range of blocks", vis).group(*baseGroup, Group.General)
+    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks", vis).group(*baseGroup, Group.General)
+    override val interactionsPerTick by c.setting("Interactions Per Tick", 5, 1..30, 1, "The amount of interactions that can happen per tick", visibility = vis).group(*baseGroup, Group.General)
+    override val maxPendingInteractions by c.setting("Max Pending Interactions", 15, 1..30, 1, "The maximum count of pending interactions to allow before pausing future interactions", visibility = vis).group(*baseGroup, Group.General)
+
+    override val useDefaultReach by c.setting("Default Reach", true, "Whether to use vanilla interaction ranges", vis).group(*baseGroup, Group.Reach)
+    override val attackReach by c.setting("Attack Reach", DEFAULT_ATTACK_REACH, 1.0..10.0, 0.01, "Maximum entity interaction distance") { vis() && !useDefaultReach }.group(*baseGroup, Group.Reach)
+    override val interactReach by c.setting("Interact Reach", DEFAULT_INTERACT_REACH, 1.0..10.0, 0.01, "Maximum block interaction distance") { vis() && !useDefaultReach }.group(*baseGroup, Group.Reach)
+
+    override val scanReach: Double get() = max(attackReach, interactReach)
+
+    override val strictRayCast by c.setting("Strict Raycast", false, "Whether to include the environment to the ray cast context", vis).group(*baseGroup, Group.Scan)
+    override val checkSideVisibility by c.setting("Visibility Check", true, "Whether to check if an AABB side is visible", vis).group(*baseGroup, Group.Scan)
+    override val resolution by c.setting("Resolution", 5, 1..20, 1, "The amount of grid divisions per surface of the hit box", "", vis).group(*baseGroup, Group.Scan)
+    override val pointSelection by c.setting("Point Selection", PointSelection.Optimum, "The strategy to select the best hit point", vis).group(*baseGroup, Group.Scan)
+
+    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks", visibility = vis)
+
+    companion object {
+        const val DEFAULT_ATTACK_REACH = 3.0
+        const val DEFAULT_INTERACT_REACH = 4.5
+    }
 }

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

@@ -24,12 +24,12 @@ import com.lambda.util.NamedEnum
 
 class InteractSettings(
     c: Configurable,
-    groupPath: List<NamedEnum> = emptyList(),
+    baseGroup: NamedEnum,
     vis: () -> Boolean = { true }
 ) : InteractConfig, SettingGroup(c, c.settings.size) {
-    override val rotate by c.setting("Rotate For Interact", true, "Rotates the player to look at the block when interacting", visibility = vis).group(groupPath)
-    override val swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting", visibility = vis).group(groupPath)
-    override val interactStageMask by c.setting("Interact Stage Mask", setOf(TickEvent.Input.Post), description = "The sub-tick timing at which interact actions are performed", visibility = vis).group(groupPath)
-    override val interactSwingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swingHand }.group(groupPath)
-    override val interactConfirmationMode by c.setting("Interact Confirmation Mode", InteractionConfig.InteractConfirmationMode.InteractThenAwait, "The style of confirmation for interactions", visibility = vis).group(groupPath)
+    override val rotate by c.setting("Rotate For Interact", true, "Rotates the player to look at the block when interacting", visibility = vis).group(baseGroup)
+    override val swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting", visibility = vis).group(baseGroup)
+    override val interactStageMask by c.setting("Interact Stage Mask", setOf(TickEvent.Input.Post), description = "The sub-tick timing at which interact actions are performed", visibility = vis).group(baseGroup)
+    override val interactSwingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swingHand }.group(baseGroup)
+    override val interactConfirmationMode by c.setting("Interact Confirmation Mode", InteractConfig.InteractConfirmationMode.InteractThenAwait, "The style of confirmation for interactions", visibility = vis).group(baseGroup)
 }

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

@@ -26,17 +26,17 @@ import com.lambda.util.NamedEnum
 
 class PlaceSettings(
     c: Configurable,
-    groupPath: List<NamedEnum> = emptyList(),
+    baseGroup: NamedEnum,
     vis: () -> Boolean = { true }
 ) : PlaceConfig, SettingGroup(c, c.settings.size) {
-    override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing", visibility = vis).group(groupPath)
-    override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces", visibility = vis).group(groupPath)
-    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 }.group(groupPath)
-    override val placeStageMask by c.setting("Place Stage mask", setOf(TickEvent.Input.Post), description = "The sub-tick timing at which place actions are performed", visibility = vis).group(groupPath)
-    override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation", visibility = vis).group(groupPath)
-    override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements", visibility = vis).group(groupPath)
-    override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick", visibility = vis).group(groupPath)
-    override val swing by c.setting("Swing On Place", true, "Swings the players hand when placing", visibility = vis).group(groupPath)
-    override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing }.group(groupPath)
-    override val sounds by c.setting("Place Sounds", true, "Plays the placing sounds", visibility = vis).group(groupPath)
+    override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing", visibility = vis).group(baseGroup)
+    override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces", visibility = vis).group(baseGroup)
+    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 }.group(baseGroup)
+    override val placeStageMask by c.setting("Place Stage mask", setOf(TickEvent.Input.Post), description = "The sub-tick timing at which place actions are performed", visibility = vis).group(baseGroup)
+    override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation", visibility = vis).group(baseGroup)
+    override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements", visibility = vis).group(baseGroup)
+    override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick", visibility = vis).group(baseGroup)
+    override val swing by c.setting("Swing On Place", true, "Swings the players hand when placing", visibility = vis).group(baseGroup)
+    override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing }.group(baseGroup)
+    override val sounds by c.setting("Place Sounds", true, "Plays the placing sounds", visibility = vis).group(baseGroup)
 }

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

@@ -19,20 +19,20 @@ package com.lambda.context
 
 import com.lambda.config.groups.BuildConfig
 import com.lambda.config.groups.EatConfig
-import com.lambda.config.groups.InteractionConfig
+import com.lambda.interaction.request.breaking.BreakConfig
 import com.lambda.interaction.request.hotbar.HotbarConfig
+import com.lambda.interaction.request.interacting.InteractConfig
 import com.lambda.interaction.request.inventory.InventoryConfig
+import com.lambda.interaction.request.placing.PlaceConfig
 import com.lambda.interaction.request.rotating.RotationConfig
 
 interface Automated {
     val buildConfig: BuildConfig
+    val breakConfig: BreakConfig
+    val placeConfig: PlaceConfig
+    val interactConfig: InteractConfig
     val rotationConfig: RotationConfig
-    val interactionConfig: InteractionConfig
     val inventoryConfig: InventoryConfig
     val hotbarConfig: HotbarConfig
     val eatConfig: EatConfig
-}
-
-val Automated.breakConfig get() = buildConfig.breakConfig
-val Automated.placeConfig get() = buildConfig.placeConfig
-val Automated.interactConfig get() = buildConfig.interactConfig
+}

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

@@ -19,22 +19,26 @@ package com.lambda.context
 
 import com.lambda.config.Configurable
 import com.lambda.config.configurations.LambdaConfig
+import com.lambda.config.groups.BreakSettings
 import com.lambda.config.groups.BuildSettings
 import com.lambda.config.groups.EatSettings
 import com.lambda.config.groups.HotbarSettings
-import com.lambda.config.groups.InteractionSettings
+import com.lambda.config.groups.InteractSettings
 import com.lambda.config.groups.InventorySettings
+import com.lambda.config.groups.PlaceSettings
 import com.lambda.config.groups.RotationSettings
 import com.lambda.event.events.onStaticRender
 import com.lambda.interaction.construction.result.Drawable
 import com.lambda.util.NamedEnum
-import com.lambda.util.world.raycast.InteractionMask
 
 object AutomationConfig : Configurable(LambdaConfig), Automated {
     override val name = "automation"
 
     enum class Group(override val displayName: String) : NamedEnum {
         Build("Build"),
+        Break("Break"),
+        Place("Place"),
+        Interact("Interact"),
         Rotation("Rotation"),
         Interaction("Interaction"),
         Inventory("Inventory"),
@@ -47,8 +51,10 @@ object AutomationConfig : Configurable(LambdaConfig), Automated {
     val renders by setting("Render", false).group(Group.Render)
 
     override val buildConfig = BuildSettings(this, Group.Build)
+    override val breakConfig = BreakSettings(this, Group.Break)
+    override val placeConfig = PlaceSettings(this, Group.Place)
+    override val interactConfig = InteractSettings(this, Group.Interact)
     override val rotationConfig = RotationSettings(this, Group.Rotation)
-    override val interactionConfig = InteractionSettings(this, Group.Interaction, InteractionMask.Both)
     override val inventoryConfig = InventorySettings(this, Group.Inventory)
     override val hotbarConfig = HotbarSettings(this, Group.Hotbar)
     override val eatConfig = EatSettings(this, Group.Eat)