Refactor placement handling in BuildTask implementation

Lifted placement-related logic into the BuildTask to simplify task nesting and enhance data flow. This change improves maintainability and ensures more accessible context sharing across the build process.

Author: Avanatiker

common/src/main/kotlin/com/lambda/command/commands/BuildCommand.kt

@@ -46,38 +46,34 @@ object BuildCommand : LambdaCommand(
             required(greedyString("structure")) { structure ->
                 suggests { _, builder ->
                     StructureRegistry.forEach { key, _ -> builder.suggest(key) }
-
                     builder.buildFuture()
                 }
-                optional(boolean("pathing")) { pathing ->
-                    executeWithResult {
-                        val pathString = structure().value()
-                        val doPathing = if (pathing != null) pathing().value() else false
-                        runSafe<Unit> {
-                            try {
-                                StructureRegistry
-                                    .loadStructureByRelativePath(Path.of(pathString))
-                                    ?.let { template ->
-                                        info("Building structure $pathString with dimensions ${template.size.toShortString()} created by ${template.author}")
-                                        template.toStructure()
-                                            .move(player.blockPos)
-                                            .toBlueprint()
-                                            .build(pathing = doPathing)
-                                            .run()
+                executeWithResult {
+                    val pathString = structure().value()
+                    runSafe<Unit> {
+                        try {
+                            StructureRegistry
+                                .loadStructureByRelativePath(Path.of(pathString))
+                                ?.let { template ->
+                                    info("Building structure $pathString with dimensions ${template.size.toShortString()} created by ${template.author}")
+                                    template.toStructure()
+                                        .move(player.blockPos)
+                                        .toBlueprint()
+                                        .build()
+                                        .run()
 
-                                        return@executeWithResult CommandResult.success()
-                                    }
-                            } catch (e: InvalidPathException) {
-                                return@executeWithResult CommandResult.failure("Invalid path $pathString")
-                            } catch (e: NoSuchFileException) {
-                                return@executeWithResult CommandResult.failure("Structure $pathString not found")
-                            } catch (e: Exception) {
-                                return@executeWithResult CommandResult.failure(e.message ?: "Failed to load structure $pathString")
-                            }
+                                    return@executeWithResult CommandResult.success()
+                                }
+                        } catch (e: InvalidPathException) {
+                            return@executeWithResult CommandResult.failure("Invalid path $pathString")
+                        } catch (e: NoSuchFileException) {
+                            return@executeWithResult CommandResult.failure("Structure $pathString not found")
+                        } catch (e: Exception) {
+                            return@executeWithResult CommandResult.failure(e.message ?: "Failed to load structure $pathString")
                         }
-
-                        CommandResult.failure("Structure $pathString not found")
                     }
+
+                    CommandResult.failure("Structure $pathString not found")
                 }
             }
         }

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

@@ -18,12 +18,23 @@
 package com.lambda.config.groups
 
 interface BuildConfig {
-    val breakConfirmation: Boolean
-    val placeConfirmation: Boolean
-    val collectDrops: Boolean
-    val breakWeakBlocks: Boolean
+    // General
     val pathing: Boolean
-    val breaksPerTick: Int
+    val stayInRange: Boolean
+    val collectDrops: Boolean
+    val forceSilkTouch: Boolean
+
+    // Breaking
     val rotateForBreak: Boolean
+    val breakConfirmation: Boolean
+    val maxPendingBreaks: Int
+    val breaksPerTick: Int
+    val breakWeakBlocks: Boolean
+
+    // Placing
     val rotateForPlace: Boolean
+    val placeConfirmation: Boolean
+    val placeTimeout: Int
+    val maxPendingPlacements: Int
+    val placementsPerTick: Int
 }

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

@@ -29,16 +29,23 @@ class BuildSettings(
 
     private val page by c.setting("Build Page", Page.GENERAL, "Current page", vis)
 
+    // General
     override val pathing by c.setting("Pathing", true, "Path to blocks") { vis() && page == Page.GENERAL }
+    override val stayInRange by c.setting("Stay In Range", true, "Stay in range of blocks") { vis() && page == Page.GENERAL && pathing }
+    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks") { vis() && page == Page.GENERAL }
 
+    // Breaking
+    override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() && page == Page.BREAK }
     override val breakConfirmation by c.setting("Break Confirmation", false, "Wait for block break confirmation") { vis() && page == Page.BREAK }
+    override val maxPendingBreaks by c.setting("Max Pending Breaks", 1, 1..10, 1, "Maximum pending block breaks") { vis() && page == Page.BREAK }
+    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() && page == Page.BREAK }
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() && page == Page.BREAK }
-    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 10, 1..30, 1, "Maximum instant block breaks per tick") { vis() && page == Page.BREAK }
-    override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() && page == Page.BREAK }
-
-    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks") { vis() && page == Page.BREAK }
-
-    override val placeConfirmation by c.setting("Place Confirmation", true, "Wait for block placement confirmation") { vis() && page == Page.PLACE }
+    override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() && page == Page.BREAK }
 
+    // Placing
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() && page == Page.PLACE }
+    override val placeConfirmation by c.setting("Place Confirmation", true, "Wait for block placement confirmation") { vis() && page == Page.PLACE }
+    override val placeTimeout by c.setting("Place Timeout", 10, 1..30, 1, "Timeout for block placement in ticks", unit = " ticks") { vis() && page == Page.PLACE && placeConfirmation }
+    override val maxPendingPlacements by c.setting("Max Pending Places", 1, 1..10, 1, "Maximum pending block places") { vis() && page == Page.PLACE }
+    override val placementsPerTick by c.setting("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() && page == Page.PLACE }
 }

…/lambda/config/groups/IRotationConfig.kt …m/lambda/config/groups/RotationConfig.ktcommon/src/main/kotlin/com/lambda/config/groups/IRotationConfig.kt renamed to common/src/main/kotlin/com/lambda/config/groups/RotationConfig.kt common/src/main/kotlin/com/lambda/config/groups/IRotationConfig.kt renamed to common/src/main/kotlin/com/lambda/config/groups/RotationConfig.kt

@@ -19,7 +19,7 @@ package com.lambda.config.groups
 
 import com.lambda.interaction.rotation.RotationMode
 
-interface IRotationConfig {
+interface RotationConfig {
     /**
      * - [RotationMode.SILENT] Spoofing server-side rotation.
      * - [RotationMode.SYNC] Spoofing server-side rotation and adjusting client-side movement based on reported rotation (for Grim).
@@ -42,7 +42,7 @@ interface IRotationConfig {
      */
     val resetTicks: Int
 
-    interface Instant : IRotationConfig {
+    interface Instant : RotationConfig {
         override val turnSpeed get() = 360.0
         override val keepTicks get() = 1
         override val resetTicks get() = 1

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

@@ -25,7 +25,7 @@ import kotlin.random.Random
 class RotationSettings(
     c: Configurable,
     vis: () -> Boolean = { true },
-) : IRotationConfig {
+) : RotationConfig {
     /**
      * The rotation mode
      */

common/src/main/kotlin/com/lambda/interaction/RotationManager.kt

@@ -60,7 +60,7 @@ object RotationManager : Loadable {
     ) {
         var lastCtx: RotationContext? = null
 
-        this.listen<RotationEvent.Update>(priority, alwaysListen) { event ->
+        listen<RotationEvent.Update>(priority, alwaysListen) { event ->
             val rotationContext = onUpdate(event.context)
 
             rotationContext?.let {
@@ -70,7 +70,7 @@ object RotationManager : Loadable {
             lastCtx = rotationContext
         }
 
-        this.listen<RotationEvent.Post> { event ->
+        listen<RotationEvent.Post> { event ->
             if (event.context == lastCtx && event.context.isValid) {
                 onReceive()
             }

common/src/main/kotlin/com/lambda/interaction/construction/blueprint/DynamicBlueprint.kt

@@ -18,19 +18,24 @@
 package com.lambda.interaction.construction.blueprint
 
 import com.lambda.context.SafeContext
+import com.lambda.threading.runSafe
 import com.lambda.util.extension.Structure
 import net.minecraft.util.math.Vec3i
 
 data class DynamicBlueprint(
     val init: SafeContext.(Structure) -> Structure = { emptyMap() },
     val update: SafeContext.(Structure) -> Structure = { it },
 ) : Blueprint() {
-    fun update(ctx: SafeContext) {
-        structure = ctx.update(structure)
+    fun update() {
+        runSafe {
+            structure = update(structure)
+        }
     }
 
-    fun create(ctx: SafeContext) {
-        structure = ctx.init(structure)
+    fun create() {
+        runSafe {
+            structure = init(structure)
+        }
     }
 
     override var structure: Structure = emptyMap()

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

@@ -58,4 +58,8 @@ data class BreakContext(
             else -> 1
         }
     }
+
+    override fun SafeContext.buildRenderer() {
+
+    }
 }

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

@@ -17,14 +17,15 @@
 
 package com.lambda.interaction.construction.context
 
+import com.lambda.interaction.construction.result.Drawable
 import com.lambda.interaction.rotation.RotationContext
 import net.minecraft.block.BlockState
 import net.minecraft.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
 
-interface BuildContext : Comparable<BuildContext> {
+interface BuildContext : Comparable<BuildContext>, Drawable {
     val pov: Vec3d
     val result: BlockHitResult
     val distance: Double

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

@@ -17,15 +17,21 @@
 
 package com.lambda.interaction.construction.context
 
+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.rotation.RotationContext
+import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils
+import com.lambda.util.Communication.warn
 import net.minecraft.block.BlockState
 import net.minecraft.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 import net.minecraft.util.math.Vec3d
+import java.awt.Color
 
 data class PlaceContext(
     override val pov: Vec3d,
@@ -39,10 +45,35 @@ data class PlaceContext(
     val targetState: TargetState,
     val sneak: Boolean,
     val insideBlock: Boolean,
-    val primeDirection: Direction?
+    val primeDirection: Direction?,
 ) : BuildContext {
-    override fun compareTo(other: BuildContext): Int {
-        return when (other) {
+    var placeTick = 0L
+    private val baseColor = Color(35, 188, 254, 25)
+    private val sideColor = Color(35, 188, 254, 100)
+
+    fun place(swingHand: Boolean) {
+        runSafe {
+            val actionResult = interaction.interactBlock(
+                player, hand, result
+            )
+
+            if (actionResult.isAccepted) {
+                if (actionResult.shouldSwingHand() && swingHand) {
+                    player.swingHand(hand)
+                }
+
+                if (!player.getStackInHand(hand).isEmpty && interaction.hasCreativeInventory()) {
+                    mc.gameRenderer.firstPersonRenderer.resetEquipProgress(hand)
+                }
+                placeTick = mc.uptimeInTicks
+            } else {
+                warn("Internal interaction failed with $actionResult")
+            }
+        }
+    }
+
+    override fun compareTo(other: BuildContext) =
+        when (other) {
             is PlaceContext -> compareBy<PlaceContext> {
                 BlockUtils.fluids.indexOf(it.checkedState.fluidState.fluid)
             }.thenByDescending {
@@ -59,5 +90,9 @@ data class PlaceContext(
 
             else -> 1
         }
+
+    override fun SafeContext.buildRenderer() {
+        withState(expectedState, expectedPos, baseColor, DirectionMask.ALL.exclude(result.side.opposite))
+        withState(expectedState, expectedPos, sideColor, result.side.opposite)
     }
 }