Fix BuildTask placing timings

Author: Avanatiker

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

@@ -63,13 +63,13 @@ object RotationManager : Loadable {
     fun Any.rotate(
         priority: Int = 0,
         alwaysListen: Boolean = false,
-        block: RequestRotationBuilder.() -> Unit,
+        block: RotationRequestBuilder.() -> Unit,
     ) {
-        val builder = RequestRotationBuilder().apply(block)
+        val builder = RotationRequestBuilder().apply(block)
         var lastRequest: RotationRequest? = null
 
         listen<RotationEvent.Update>(priority, alwaysListen) { event ->
-            val rotationRequest = builder.onUpdate?.invoke(this, event.request)
+            val rotationRequest = builder.request?.invoke(this, event.request)
 
             rotationRequest?.let {
                 event.request = it
@@ -80,26 +80,26 @@ object RotationManager : Loadable {
 
         listen<RotationEvent.Post> { event ->
             if (event.request == lastRequest) {
-                builder.onReceive?.invoke(this, event.request)
+                builder.onFinish?.invoke(this, event.request)
             }
         }
     }
 
     @DslMarker
     annotation class RotationDsl
 
-    class RequestRotationBuilder {
-        var onUpdate: (SafeContext.(lastContext: RotationRequest?) -> RotationRequest?)? = null
-        var onReceive: (SafeContext.(context: RotationRequest) -> Unit)? = null
+    class RotationRequestBuilder {
+        var request: (SafeContext.(lastContext: RotationRequest?) -> RotationRequest?)? = null
+        var onFinish: (SafeContext.(context: RotationRequest) -> Unit)? = null
 
         @RotationDsl
-        fun onUpdate(block: SafeContext.(lastContext: RotationRequest?) -> RotationRequest?) {
-            onUpdate = block
+        fun request(block: SafeContext.(lastContext: RotationRequest?) -> RotationRequest?) {
+            request = block
         }
 
         @RotationDsl
-        fun onReceive(block: SafeContext.(context: RotationRequest) -> Unit) {
-            onReceive = block
+        fun finished(block: SafeContext.(context: RotationRequest) -> Unit) {
+            onFinish = block
         }
     }
 

common/src/main/kotlin/com/lambda/module/modules/combat/KillAura.kt

@@ -115,8 +115,8 @@ object KillAura : Module(
 
     init {
         rotate {
-            onUpdate {
-                if (!rotate) return@onUpdate null
+            request {
+                if (!rotate) return@request null
 
                 target?.let { target ->
                     buildRotation(target)

common/src/main/kotlin/com/lambda/module/modules/movement/Speed.kt

@@ -135,14 +135,14 @@ object Speed : Module(
         }
 
         rotate(100, alwaysListen = false) {
-            onUpdate { lastContext ->
-                if (mode != Mode.GRIM_STRAFE) return@onUpdate null
-                if (!shouldWork()) return@onUpdate null
+            request { lastContext ->
+                if (mode != Mode.GRIM_STRAFE) return@request null
+                if (!shouldWork()) return@request null
 
                 var yaw = player.yaw
                 val input = newMovementInput()
 
-                if (!input.isInputting) return@onUpdate null
+                if (!input.isInputting) return@request null
 
                 run {
                     if (!diagonal) return@run

common/src/main/kotlin/com/lambda/module/modules/player/Scaffold.kt

@@ -124,10 +124,10 @@ object Scaffold : Module(
 
     init {
         rotate {
-            onUpdate {
+            request {
                 lastRotation = null
-                val info = updatePlaceInfo() ?: return@onUpdate null
-                val rotation = rotate(info) ?: return@onUpdate null
+                val info = updatePlaceInfo() ?: return@request null
+                val rotation = rotate(info) ?: return@request null
 
                 RotationRequest(rotation, rotationConfig)
             }

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

@@ -81,13 +81,13 @@ class BreakBlock @Ta5kBuilder constructor(
 
     init {
         rotate {
-            onUpdate {
-                if (state != State.BREAKING) return@onUpdate null
-                if (!rotate || ctx.instantBreak) return@onUpdate null
+            request {
+                if (state != State.BREAKING) return@request null
+                if (!rotate || ctx.instantBreak) return@request null
 
                 lookAtBlock(blockPos, rotation, interact, sides)
             }
-            onReceive { context ->
+            finished { context ->
                 isValid = context.isValid
             }
         }

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

@@ -43,12 +43,11 @@ import com.lambda.task.Task
 import com.lambda.util.BaritoneUtils
 import com.lambda.util.BlockUtils
 import com.lambda.util.BlockUtils.blockState
-import com.lambda.util.Communication.info
 import com.lambda.util.Formatting.string
+import com.lambda.util.collections.LimitedDecayQueue
 import com.lambda.util.extension.Structure
 import net.minecraft.network.packet.s2c.play.BlockUpdateS2CPacket
 import net.minecraft.util.math.BlockPos
-import java.util.concurrent.ConcurrentLinkedQueue
 
 class BuildTask @Ta5kBuilder constructor(
     private val blueprint: Blueprint,
@@ -60,35 +59,24 @@ class BuildTask @Ta5kBuilder constructor(
 ) : Task<Unit>() {
     override val name: String get() = "Building $blueprint with ${(placements / (age / 20.0 + 0.001)).string} p/s"
 
-    private val pendingPlacements = ConcurrentLinkedQueue<PlaceContext>()
-    private val pendingBreaks = ConcurrentLinkedQueue<BreakContext>()
+    private val pendingPlacements = LimitedDecayQueue<PlaceContext>(20, 1000)
+    private val pendingBreaks = LimitedDecayQueue<BreakContext>(20, 1000)
 
     private var currentPlacement: PlaceContext? = null
     private var placements = 0
     private var breaks = 0
-    private var inScope = 0
 
     override fun SafeContext.onStart() {
         (blueprint as? DynamicBlueprint)?.create()
     }
 
     init {
         listen<TickEvent.Pre> {
-            pendingPlacements.removeIf {
-                val timeout = (mc.uptimeInTicks - it.placeTick) > build.placeTimeout
-                if (timeout) {
-                    info("Placement Timeout of ${it.expectedPos.toShortString()}")
-                }
-                timeout
-            }
-
             currentPlacement?.let { context ->
-                if (!context.rotation.isValid) return@listen
-                if (inScope++ < 1) return@listen // ToDo: Should not be needed but timings are wrong
+                if (!context.rotation.isValid) return@let
                 context.place(interact.swingHand)
                 pendingPlacements.add(context)
                 currentPlacement = null
-                inScope = 0
             }
 
             (blueprint as? DynamicBlueprint)?.update()
@@ -161,9 +149,8 @@ class BuildTask @Ta5kBuilder constructor(
         }
 
         rotate {
-            onUpdate {
-                if (currentPlacement == null) return@onUpdate null
-                if (!build.rotateForPlace) return@onUpdate null
+            request {
+                if (!build.rotateForPlace) return@request null
                 currentPlacement?.rotation
             }
         }