Fix rotation validity checks and crystal placement

Author: Avanatiker

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

@@ -66,21 +66,22 @@ object RotationManager : Loadable {
         block: RequestRotationBuilder.() -> Unit,
     ) {
         val builder = RequestRotationBuilder().apply(block)
-        var lastCtx: RotationContext? = null
+        var requested: RotationContext? = null
 
         listen<RotationEvent.Update>(priority, alwaysListen) { event ->
             builder.onUpdate?.invoke(this, event.context)?.let { context ->
                 if (!context.config.rotate) return@let
                 event.context = context
-                lastCtx = context
+                requested = context
             }
         }
 
         listen<RotationEvent.Post> { event ->
-            if (!event.context.config.rotate) return@listen
-            if (event.context == lastCtx) {
-                builder.onReceive?.invoke(this, event.context)
-            }
+            val context = event.context
+            if (!context.config.rotate) return@listen
+            if (context != requested) return@listen
+            if (!context.isValid) return@listen
+            builder.onReceive?.invoke(this, context)
         }
     }
 
@@ -92,12 +93,12 @@ object RotationManager : Loadable {
         var onReceive: (SafeContext.(context: RotationContext) -> Unit)? = null
 
         @RotationDsl
-        fun onUpdate(block: SafeContext.(lastContext: RotationContext?) -> RotationContext?) {
+        fun request(block: SafeContext.(lastContext: RotationContext?) -> RotationContext?) {
             onUpdate = block
         }
 
         @RotationDsl
-        fun onReceive(block: SafeContext.(context: RotationContext) -> Unit) {
+        fun finished(block: SafeContext.(context: RotationContext) -> Unit) {
             onReceive = block
         }
     }

common/src/main/kotlin/com/lambda/interaction/rotation/RotationContext.kt

@@ -18,6 +18,8 @@
 package com.lambda.interaction.rotation
 
 import com.lambda.config.groups.RotationConfig
+import com.lambda.interaction.RotationManager
+import com.lambda.threading.runSafe
 import com.lambda.util.world.raycast.RayCastUtils.orMiss
 import net.minecraft.util.hit.HitResult
 
@@ -27,5 +29,9 @@ data class RotationContext(
     val hitResult: HitResult? = null,
     val verify: HitResult.() -> Boolean = { true },
 ) {
-    val isValid: Boolean get() = verify(hitResult.orMiss)
+    val isValid: Boolean get() = runSafe {
+        // ToDo: Use proper reach
+        val result = RotationManager.currentRotation.rayCast(10.0, player.eyePos)
+        verify(result.orMiss)
+    } ?: false
 }

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

@@ -22,9 +22,11 @@ import com.lambda.config.groups.RotationSettings
 import com.lambda.config.groups.Targeting
 import com.lambda.context.SafeContext
 import com.lambda.event.events.RenderEvent
+import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.graphics.renderer.esp.builders.ofShape
 import com.lambda.interaction.RotationManager.rotate
+import com.lambda.interaction.rotation.RotationContext
 import com.lambda.interaction.visibilty.VisibilityChecker.lookAtBlock
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
@@ -34,10 +36,10 @@ import com.lambda.util.combat.CombatUtils.explosionDamage
 import com.lambda.util.math.VecUtils.dist
 import com.lambda.util.math.VecUtils.vec3d
 import com.lambda.util.math.transform
-import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.entity.LivingEntity
 import net.minecraft.util.Hand
+import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box
 import net.minecraft.util.math.Vec3d
@@ -86,20 +88,34 @@ object CrystalAura : Module(
     private val placements = LimitedDecayQueue<BlockPos>(64, 1000L)
     private val target: LivingEntity? get() = targeting.target()
 
+    private var currentRotation: RotationContext? = null
+
     init {
-        rotate {
-            onUpdate {
-                val targetEntity = target ?: return@onUpdate null
-                val validPositions = findTargetPositions(targetEntity)
+        listen<TickEvent.Pre> {
+            currentRotation?.let { rotate ->
+                if (!rotate.isValid) return@let
+                (rotate.hitResult as? BlockHitResult)?.let { result ->
+                    interaction.interactBlock(player, Hand.MAIN_HAND, result)
+                    placements.add(result.blockPos)
+                    currentRotation = null
+                }
+            }
 
+            target?.let { tar ->
+                val validPositions = findTargetPositions(tar).filter { it.blockPos !in placements }
                 testRender.addAll(validPositions.map { it.blockPos })
-
-                validPositions.firstNotNullOfOrNull {
-                    lookAtBlock(it.blockPos, rotation, interact)
+                currentRotation = validPositions.firstNotNullOfOrNull {
+                    lookAtBlock(it.blockPos.toImmutable(), rotation, interact)
                 }
             }
         }
 
+        rotate {
+            request {
+                currentRotation
+            }
+        }
+
         listen<RenderEvent.StaticESP> {
 //            worldCrystals(target ?: return@listen).forEach { crystal ->
 //                it.renderer.build(

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

@@ -113,8 +113,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
 
                 RotationContext(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

@@ -161,9 +161,9 @@ class BuildTask @Ta5kBuilder constructor(
         }
 
         rotate {
-            onUpdate {
-                if (currentPlacement == null) return@onUpdate null
-                if (!build.rotateForPlace) return@onUpdate null
+            request {
+                if (currentPlacement == null) return@request null
+                if (!build.rotateForPlace) return@request null
                 currentPlacement?.rotation
             }
         }