Kill aura

Author: bladekt

common/src/main/java/com/lambda/mixin/MinecraftClientMixin.java

@@ -6,10 +6,10 @@
 import com.lambda.event.events.ScreenEvent;
 import com.lambda.event.events.ScreenHandlerEvent;
 import com.lambda.event.events.TickEvent;
+import com.lambda.interaction.RotationManager;
 import com.lambda.module.modules.player.Interact;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.screen.Screen;
-import net.minecraft.client.gui.screen.ingame.HandledScreen;
 import net.minecraft.client.gui.screen.ingame.ScreenHandlerProvider;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
 import org.jetbrains.annotations.Nullable;
@@ -27,6 +27,7 @@ public class MinecraftClientMixin {
     @Inject(method = "tick", at = @At("HEAD"))
     void onTickPre(CallbackInfo ci) {
         EventFlow.post(new TickEvent.Pre());
+        RotationManager.update();
     }
 
     @Inject(method = "tick", at = @At("RETURN"))

common/src/main/java/com/lambda/mixin/entity/PlayerEntityMixin.java

@@ -28,4 +28,14 @@ private float injectHeadYaw(PlayerEntity instance) {
         Float yaw = RotationManager.getRenderYaw();
         return (yaw != null) ? yaw : instance.getYaw();
     }
+
+    @Redirect(method = "attack", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/player/PlayerEntity;getYaw()F"))
+    private float injectAttackFix(PlayerEntity instance) {
+        if ((Object) this != MinecraftClient.getInstance().player) {
+            return instance.getYaw();
+        }
+
+        Float yaw = RotationManager.getMovementYaw();
+        return (yaw != null) ? yaw : instance.getYaw();
+    }
 }

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

@@ -1,14 +1,14 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
-import com.lambda.util.world.raycast.RayCastMask
 
 class InteractionSettings(
     c: Configurable,
+    defaultReach: Double = 4.9,
     vis: () -> Boolean = { true },
 ) : InteractionConfig {
-    override val reach by c.setting("Reach", 4.9, 0.1..10.0, 0.1, "Players reach / range", " blocks", vis)
+    override val reach by c.setting("Reach", defaultReach, 0.1..10.0, 0.1, "Players reach / range", " blocks", vis)
     override val useRayCast by c.setting("Raycast", false, "Verify hit vector with ray casting (for very strict ACs)", vis)
-    override val resolution by c.setting("Resolution", 5, 1..20, 1, "How many raycast checks per surface (will be squared)") { vis() && useRayCast }
+    override val resolution by c.setting("Resolution", 10, 1..30, 1, "How many raycast checks per surface (will be squared)") { vis() && useRayCast }
     override val swingHand by c.setting("Swing Hand", true, "Swing hand on interactions", vis)
 }

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

@@ -22,7 +22,7 @@ class RotationSettings(
     /**
      * If true, rotation will be instant without any transition. If false, rotation will transition over time.
      */
-    private var instant by c.setting("Instant Rotation", true, "Instantly rotate", vis)
+    var instant by c.setting("Instant Rotation", true, "Instantly rotate", vis)
 
     /**
      * The mean (average/base) value used to calculate rotation speed.

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

@@ -50,9 +50,6 @@ object PlayerPacketManager : Loadable {
         val (yaw, pitch) = rotation.float
         val onGround = new.onGround
 
-        // Fix sensitivity for absolutely any outgoing angle
-        RotationManager.currentRotation = rotation.fixSensitivity(RotationManager.prevRotation)
-
         if (player.hasVehicle()) {
             connection.sendPacket(
                 Full(

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

@@ -2,13 +2,15 @@ package com.lambda.interaction
 
 import com.lambda.Lambda.mc
 import com.lambda.config.groups.RotationSettings
+import com.lambda.context.SafeContext
 import com.lambda.core.Loadable
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.*
 import com.lambda.event.listener.SafeListener.Companion.listener
 import com.lambda.event.listener.UnsafeListener.Companion.unsafeListener
 import com.lambda.interaction.rotation.Rotation
 import com.lambda.interaction.rotation.Rotation.Companion.angleDifference
+import com.lambda.interaction.rotation.Rotation.Companion.fixSensitivity
 import com.lambda.interaction.rotation.Rotation.Companion.slerp
 import com.lambda.interaction.rotation.RotationContext
 import com.lambda.interaction.rotation.RotationMode
@@ -33,17 +35,43 @@ object RotationManager : Loadable {
     private var keepTicks = 0
     private var pauseTicks = 0
 
-    init {
-        listener<TickEvent.Pre> {
-            RotationEvent.Update(BaritoneProcessor.poolContext()).post {
-                rotate(context)
+    fun Any.requestRotation(
+        priority: Int = 0,
+        alwaysListen: Boolean = false,
+        onUpdate: SafeContext.() -> RotationContext?,
+        onReceive: SafeContext.() -> Unit
+    ) {
+        var lastCtx: RotationContext? = null
 
-                currentContext?.let {
-                    RotationEvent.Post(it).post()
-                }
+        this.listener<RotationEvent.Update>(priority, alwaysListen) { event ->
+            val rotationContext = onUpdate()
+
+            rotationContext?.let {
+                event.context = it
+            }
+
+            lastCtx = rotationContext
+        }
+
+        this.listener<RotationEvent.Post> { event ->
+            if (event.context == lastCtx && event.context.isValid) {
+                onReceive()
             }
         }
+    }
 
+    @JvmStatic
+    fun update() = runSafe {
+        RotationEvent.Update(BaritoneProcessor.poolContext()).post {
+            rotate(context)
+
+            currentContext?.let {
+                RotationEvent.Post(it).post()
+            }
+        }
+    }
+
+    init {
         listener<PacketEvent.Send.Post> { event ->
             val packet = event.packet
             if (packet !is PlayerPositionLookS2CPacket) return@listener
@@ -85,6 +113,7 @@ object RotationManager : Loadable {
 
             currentRotation
                 .slerp(rotationTo, turnSpeed)
+                .fixSensitivity(prevRotation)
                 .apply {
                     if (context.config.rotationMode != RotationMode.LOCK) return@apply
                     player.yaw = this.yawF

common/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt

@@ -12,7 +12,7 @@ import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.material.ContainerManager.findBestAvailableTool
 import com.lambda.interaction.rotation.Rotation.Companion.rotationTo
 import com.lambda.interaction.rotation.RotationContext
-import com.lambda.interaction.visibilty.VisibilityChecker.mostCenter
+import com.lambda.interaction.visibilty.VisibilityChecker.optimum
 import com.lambda.interaction.visibilty.VisibilityChecker.scanVisibleSurfaces
 import com.lambda.module.modules.client.TaskFlow
 import com.lambda.threading.runSafe
@@ -160,7 +160,7 @@ object BuildSimulator {
                 return@forEach
             }
 
-            validHits.keys.mostCenter?.let { optimum ->
+            validHits.keys.optimum?.let { optimum ->
                 validHits.minByOrNull { optimum distSq it.key }?.let { closest ->
                     val optimumRotation = eye.rotationTo(closest.key)
                     RotationContext(optimumRotation, rotation, closest.value, verify)
@@ -368,7 +368,7 @@ object BuildSimulator {
             }
         }
 
-        validHits.keys.mostCenter?.let { optimum ->
+        validHits.keys.optimum?.let { optimum ->
             validHits.minByOrNull { optimum distSq it.key }?.let { closest ->
                 val optimumRotation = eye.rotationTo(closest.key)
                 RotationContext(optimumRotation, rotation, closest.value, verify)

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

@@ -4,9 +4,13 @@ import com.lambda.Lambda.mc
 import com.lambda.threading.runSafe
 import com.lambda.util.math.MathUtils.toDegree
 import com.lambda.util.math.MathUtils.toRadian
+import com.lambda.util.math.Vec2d
+import com.lambda.util.math.VecUtils.plus
+import com.lambda.util.math.VecUtils.times
 import com.lambda.util.world.raycast.RayCastMask
 import com.lambda.util.world.raycast.RayCastUtils.rayCast
 import net.minecraft.entity.Entity
+import net.minecraft.util.math.Box
 import net.minecraft.util.math.Direction
 import net.minecraft.util.math.MathHelper
 import net.minecraft.util.math.Vec3d
@@ -42,6 +46,15 @@ data class Rotation(val yaw: Double, val pitch: Double) {
         rayCast(eye ?: player.eyePos, vector, reach, mask, fluids)
     }
 
+    fun castBox(
+        box: Box,
+        reach: Double,
+        eye: Vec3d? = null
+    ) = runSafe {
+        val eyeVec = eye ?: player.eyePos
+        box.raycast(eyeVec, eyeVec + vector * reach).orElse(null)
+    }
+
     val Direction.yaw: Float
         get() = when (this) {
             Direction.NORTH -> -180.0f
@@ -79,20 +92,16 @@ data class Rotation(val yaw: Double, val pitch: Double) {
             return Rotation(yaw, pitch)
         }
 
-        fun Rotation.fixSensitivity(last: Rotation): Rotation {
+        fun Rotation.fixSensitivity(prev: Rotation): Rotation {
             val f = mc.options.mouseSensitivity.value * 0.6 + 0.2
-            val step = f * f * f * 8.0 * 0.15F
-
-            val deltaYaw = yaw - last.yaw
-            var fixedYaw = (deltaYaw / step).roundToInt() * step
-            fixedYaw += last.yaw
+            val gcd = f * f * f * 8.0 * 0.15F
 
-            val deltaPitch = pitch - last.pitch
-            var fixedPitch = (deltaPitch / step).roundToInt() * step
-            fixedPitch += last.pitch
-            fixedPitch = fixedPitch.coerceIn(-90.0, 90.0)
+            val r1 = Vec2d(prev.yaw, prev.pitch)
+            val r2 = Vec2d(this.yaw, this.pitch)
+            val delta = ((r2 - r1) / gcd).roundToInt() * gcd
+            val fixed = r1 + delta
 
-            return Rotation(fixedYaw, fixedPitch)
+            return Rotation(fixed.x, fixed.y.coerceIn(-90.0, 90.0))
         }
 
         fun Vec3d.rotationTo(vec: Vec3d): Rotation {

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

@@ -1,6 +1,7 @@
 package com.lambda.interaction.rotation
 
 import com.lambda.config.groups.IRotationConfig
+import com.lambda.util.world.raycast.RayCastUtils.orMiss
 import net.minecraft.util.hit.HitResult
 
 data class RotationContext(
@@ -9,5 +10,5 @@ data class RotationContext(
     val hitResult: HitResult? = null,
     val verify: HitResult.() -> Boolean = { true },
 ) {
-    val isValid: Boolean get() = hitResult?.verify() == true
+    val isValid: Boolean get() = verify(hitResult.orMiss)
 }

common/src/main/kotlin/com/lambda/interaction/visibilty/VisibilityChecker.kt

@@ -4,6 +4,7 @@ import com.lambda.config.groups.IRotationConfig
 import com.lambda.config.groups.InteractionConfig
 import com.lambda.context.SafeContext
 import com.lambda.interaction.RotationManager
+import com.lambda.interaction.rotation.Rotation.Companion.dist
 import com.lambda.interaction.rotation.Rotation.Companion.rotationTo
 import com.lambda.interaction.rotation.RotationContext
 import com.lambda.module.modules.client.TaskFlow
@@ -46,37 +47,42 @@ object VisibilityChecker {
 
     fun SafeContext.findRotation(
         boxes: List<Box>,
-        rotationConfig: IRotationConfig = TaskFlow.rotation,
-        interact: InteractionConfig = TaskFlow.interact,
+        rotationConfig: IRotationConfig,
+        interact: InteractionConfig,
         sides: Set<Direction> = emptySet(),
+        reach: Double = interact.reach,
+        eye: Vec3d = player.getCameraPosVec(1f),
         verify: HitResult.() -> Boolean,
     ): RotationContext? {
-        val eye = player.getCameraPosVec(mc.tickDelta)
-
         val currentRotation = RotationManager.currentRotation
-        val currentCast = currentRotation.rayCast(interact.reach, eye)
+        val currentCast = currentRotation.rayCast(reach, eye)
 
         if (boxes.any { it.contains(eye) }) {
             return RotationContext(currentRotation, rotationConfig, currentCast, verify)
         }
 
         val validHits = mutableMapOf<Vec3d, HitResult>()
-        val reachSq = interact.reach.pow(2)
+        val reachSq = reach.pow(2)
 
         boxes.forEach { box ->
-            scanVisibleSurfaces(player.eyePos, box, sides, interact.resolution) { _, vec ->
+            scanVisibleSurfaces(eye, box, sides, interact.resolution) { _, vec ->
                 if (eye distSq vec > reachSq) return@scanVisibleSurfaces
 
                 val newRotation = eye.rotationTo(vec)
 
-                val cast = newRotation.rayCast(interact.reach, eye) ?: return@scanVisibleSurfaces
+                val cast = newRotation.rayCast(reach, eye) ?: return@scanVisibleSurfaces
                 if (!cast.verify()) return@scanVisibleSurfaces
 
                 validHits[vec] = cast
             }
         }
 
-        validHits.keys.mostCenter?.let { optimum ->
+        // Way stable
+        /*validHits.minByOrNull { eye.rotationTo(it.key) dist currentRotation }?.let { closest ->
+            return RotationContext(eye.rotationTo(closest.key), rotationConfig, closest.value, verify)
+        }*/
+
+        validHits.keys.optimum?.let { optimum ->
             validHits.minByOrNull { optimum distSq it.key }?.let { closest ->
                 val optimumRotation = eye.rotationTo(closest.key)
                 return RotationContext(optimumRotation, rotationConfig, closest.value, verify)
@@ -93,11 +99,10 @@ object VisibilityChecker {
         resolution: Int,
         check: (Direction, Vec3d) -> Unit,
     ) {
-        val shrunk = box.expand(-0.005)
         box.getVisibleSurfaces(eyes)
             .forEach { side ->
                 if (sides.isNotEmpty() && side !in sides) return@forEach
-                val (minX, minY, minZ, maxX, maxY, maxZ) = shrunk.bounds(side)
+                val (minX, minY, minZ, maxX, maxY, maxZ) = box.shrink(0.01, 0.01, 0.01).bounds(side)
                 val stepX = (maxX - minX) / resolution
                 val stepY = (maxY - minY) / resolution
                 val stepZ = (maxZ - minZ) / resolution
@@ -112,7 +117,7 @@ object VisibilityChecker {
             }
     }
 
-    val Set<Vec3d>.mostCenter: Vec3d?
+    val Set<Vec3d>.optimum: Vec3d?
         get() = reduceOrNull { acc, vec3d ->
             acc.add(vec3d)
         }?.multiply(1.0 / size.toDouble())