Better build settings

Author: Avanatiker

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

@@ -1,11 +1,12 @@
 package com.lambda.config.groups
 
 interface BuildConfig {
+    val breakCoolDown: Int
+    val placeCooldown: Int
     val collectDrops: Boolean
     val breakWeakBlocks: Boolean
     val pathing: Boolean
-    val interactLimit: Int
-    val breakInstantAtOnce: Boolean
+    val breaksPerTick: Int
     val rotateForBreak: Boolean
     val swingHand: Boolean
 }

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

@@ -6,11 +6,12 @@ class BuildSettings(
     c: Configurable,
     vis: () -> Boolean = { true }
 ) : BuildConfig {
+    override val breakCoolDown by c.setting("Break Cooldown", 0, 0..20, 1, "Delay between breaking blocks", " ticks", vis)
+    override val placeCooldown by c.setting("Place Cooldown", 0, 0..20, 1, "Delay between placing blocks", " ticks", vis)
     override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks", vis)
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)", vis)
     override val pathing by c.setting("Pathing", true, "Path to blocks", vis)
-    override val interactLimit by c.setting("Interaction Limit", 15, 1..100, 1, "Max interactions per tick", " i/t", vis)
-    override val breakInstantAtOnce by c.setting("Break Instant At Once", true, "Break all instant blocks at once", vis)
+    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 10, 1..30, 1, "Maximum instant block breaks per tick", "", vis)
     override val rotateForBreak by c.setting("Rotate For Break", false, "Rotate towards block while breaking", vis)
     override val swingHand by c.setting("Swing Hand", true, "Swing hand on interactions", vis)
 }

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

@@ -12,7 +12,7 @@ class RotationSettings(
     override var rotationMode by c.setting("Mode", RotationMode.SYNC, "SILENT - server-side rotation, SYNC - server-side rotation; client-side movement, LOCK - Lock camera", vis)
     override val keepTicks by c.setting("Keep Rotation", 3, 1..10, 1, "Ticks to keep rotation", " ticks", vis)
     override val resetTicks by c.setting("Reset Rotation", 3, 1..10, 1, "Ticks before rotation is reset", " ticks", vis)
-    override var instant by c.setting("Instant Rotation", false, "Instantly rotate", vis)
+    override var instant by c.setting("Instant Rotation", true, "Instantly rotate", vis)
     override var mean by c.setting("Mean", 20.0, 1.0..80.0, 0.1, "Average rotation speed") { vis() && !instant }
     override var derivation by c.setting("Standard Deviation", 5.0, 0.0..20.0, 0.1, "Spread of rotation speeds") { vis() && !instant }
 

common/src/main/kotlin/com/lambda/task/tasks/BuildStructure.kt

@@ -11,10 +11,7 @@ import com.lambda.interaction.construction.DynamicBlueprint
 import com.lambda.interaction.construction.StaticBlueprint.Companion.toBlueprint
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.construction.context.PlaceContext
-import com.lambda.interaction.construction.result.BreakResult
-import com.lambda.interaction.construction.result.BuildResult
-import com.lambda.interaction.construction.result.PlaceResult
-import com.lambda.interaction.construction.result.Resolvable
+import com.lambda.interaction.construction.result.*
 import com.lambda.interaction.construction.simulation.BuildSimulator
 import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
 import com.lambda.interaction.construction.verify.TargetState
@@ -50,7 +47,8 @@ class BuildStructure @Ta5kBuilder constructor(
     private val blueprint: Blueprint,
     private val finishOnDone: Boolean = true,
     private val pathing: Boolean = TaskFlow.build.pathing,
-    private val collectDrops: Boolean = TaskFlow.build.collectDrops,
+    val collectDrops: Boolean = TaskFlow.build.collectDrops,
+    private val cancelOnUnsolvable: Boolean = true,
 ) : Task<Unit>() {
     private var lastTask: Task<*>? = null
 
@@ -72,33 +70,29 @@ class BuildStructure @Ta5kBuilder constructor(
             val instantResults = results.filterIsInstance<BreakResult.Success>()
                 .filter { it.context.instantBreak }
                 .sorted()
-                .take(TaskFlow.build.interactLimit)
+                .take(TaskFlow.build.breaksPerTick)
 
-            if (TaskFlow.build.breakInstantAtOnce && instantResults.isNotEmpty()) {
-//                cancelSubTasks()
+            if (TaskFlow.build.breaksPerTick > 1 && instantResults.isNotEmpty()) {
                 instantResults.forEach {
-                    it.resolve.start(this@BuildStructure, false)
+                    it.resolve.start(this@BuildStructure, pauseParent = false)
                 }
                 lastTask = instantResults.last().resolve
                 return@listener
             }
 
             results.minOrNull()?.let { result ->
-                if (!pathing && result is BuildResult.OutOfReach) return@let
+                if (!pathing && result is Navigable) return@let
 
                 if (result !is Resolvable) {
                     if (result is BuildResult.Done) {
                         checkDone()
-                    } else {
+                    } else if (cancelOnUnsolvable) {
                         failure("Failed to resolve build result: $result")
                         return@listener
                     }
                     return@listener
                 }
-//                if (lastTask?.isCompleted == false) return@listener
-
                 lastTask = result.resolve
-//                cancelSubTasks()
 
                 LOG.info("Resolving: $result")
                 result.resolve.start(this@BuildStructure)
@@ -120,12 +114,14 @@ class BuildStructure @Ta5kBuilder constructor(
             finishOnDone: Boolean = true,
             collectDrops: Boolean = TaskFlow.build.collectDrops,
             pathing: Boolean = TaskFlow.build.pathing,
+            cancelOnUnsolvable: Boolean = true,
             blueprint: () -> Blueprint,
         ) = BuildStructure(
                 blueprint(),
                 finishOnDone,
                 pathing,
                 collectDrops,
+                cancelOnUnsolvable
             )
 
         @Ta5kBuilder