Refactored movement handlers

Author: bladekt

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

@@ -55,6 +55,7 @@ void onMove(MovementType movementType, Vec3d movement, CallbackInfo ci) {
     @Redirect(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/input/Input;tick(ZF)V"))
     void processMovement(Input input, boolean slowDown, float slowDownFactor) {
         input.tick(slowDown, slowDownFactor);
+        RotationManager.BaritoneProcessor.processPlayerMovement(input, slowDown, slowDownFactor);
         EventFlow.post(new MovementEvent.InputUpdate(input, slowDown, slowDownFactor));
     }
 

common/src/main/kotlin/com/lambda/event/events/RotationEvent.kt

@@ -24,7 +24,7 @@ abstract class RotationEvent : Event {
      * @property strafeYaw The angle at which the player will move when pressing W
      * Changing this value will never force the anti cheat to flag you because RotationManager is designed to modify the key input instead
      */
-    class Strafe(var strafeYaw: Double, val input: Input) : RotationEvent()
+    class StrafeInput(var strafeYaw: Double, val input: Input) : RotationEvent()
 
     class Post(val context: RotationContext) : RotationEvent()
 }

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

@@ -1,10 +1,8 @@
 package com.lambda.interaction
 
 import com.lambda.Lambda.mc
-import com.lambda.config.groups.IRotationConfig
 import com.lambda.config.groups.RotationSettings
 import com.lambda.core.Loadable
-import com.lambda.context.SafeContext
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.*
 import com.lambda.event.listener.SafeListener.Companion.listener
@@ -20,19 +18,17 @@ import com.lambda.threading.runSafe
 import com.lambda.util.math.MathUtils.lerp
 import com.lambda.util.math.MathUtils.toRadian
 import com.lambda.util.math.Vec2d
-import com.lambda.util.player.MovementUtils.handledByBaritone
 import com.lambda.util.primitives.extension.partialTicks
 import com.lambda.util.primitives.extension.rotation
+import net.minecraft.client.input.Input
 import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket
-import net.minecraft.util.math.MathHelper
-import kotlin.math.roundToInt
-import kotlin.math.sign
+import kotlin.math.*
 
 object RotationManager : Loadable {
     var currentRotation = Rotation.ZERO
     var prevRotation = Rotation.ZERO
 
-    var currentContext: RotationContext? = null
+    private var currentContext: RotationContext? = null
 
     private var keepTicks = 0
     private var pauseTicks = 0
@@ -175,12 +171,6 @@ object RotationManager : Loadable {
             270.0, 315.0,
         )
 
-        init {
-            listener<MovementEvent.InputUpdate>(Int.MAX_VALUE) {
-                processPlayerMovement(it)
-            }
-        }
-
         @JvmStatic
         fun handleBaritoneRotation(yaw: Float, pitch: Float) {
             baritoneContext = RotationContext(Rotation(yaw, pitch), Baritone.rotation.apply {
@@ -189,47 +179,45 @@ object RotationManager : Loadable {
             })
         }
 
-        private fun SafeContext.processPlayerMovement(event: MovementEvent.InputUpdate) {
-            val config = currentContext?.config ?: return
+        @JvmStatic
+        fun processPlayerMovement(input: Input, slowDown: Boolean, slowDownFactor: Float) = runSafe {
+            // The yaw relative to which the movement was constructed
+            val baritoneYaw = baritoneContext?.rotation?.yaw
+            val strafeEvent = RotationEvent.StrafeInput(baritoneYaw ?: player.yaw.toDouble(), input)
+            val movementYaw = strafeEvent.post().strafeYaw
 
-            val input = event.input
+            // No changes are needed, when we don't modify the yaw used to move the player
+            // val config = currentContext?.config ?: return@runSafe
+            // if (config.rotationMode == RotationMode.SILENT && !input.handledByBaritone && baritoneContext == null) return@runSafe
 
             // Sign it to remove previous speed modifier
             val signForward = sign(input.movementForward)
             val signStrafe = sign(input.movementSideways)
 
             // No changes are needed when no inputs are pressed
-            if (signForward == 0f && signStrafe == 0f) return
-
-            // Movement speed modifier
-            val multiplier = if (event.slowDown) event.slowDownFactor else 1f
-
-            // No changes are needed, when we don't modify the yaw used to move the player
-            if (config.rotationMode == RotationMode.SILENT && !input.handledByBaritone && baritoneContext == null) return
-
-            // The yaw relative to which the movement was constructed
-            val baritoneYaw = baritoneContext?.rotation?.yaw
-            val strafeEvent = RotationEvent.Strafe(baritoneYaw ?: player.yaw.toDouble(), input)
-            val movementYaw = strafeEvent.post().strafeYaw
+            if (signForward == 0f && signStrafe == 0f) return@runSafe
 
             // Actual yaw used to move the player
             val actualYaw = currentRotation.yaw
 
-            val yawRad = (movementYaw - actualYaw).toRadian().toFloat()
+            val yawRad = (movementYaw - actualYaw).toRadian()
 
-            val cosDelta = MathHelper.cos(yawRad)
-            val sinDelta = MathHelper.sin(yawRad)
+            val cosDelta = cos(yawRad)
+            val sinDelta = sin(yawRad)
 
             val newX = signStrafe * cosDelta - signForward * sinDelta
             val newZ = signForward * cosDelta + signStrafe * sinDelta
 
             // Apply new movement
             input.apply {
-                movementSideways = newX.roundToInt().toFloat() * multiplier
-                movementForward = newZ.roundToInt().toFloat() * multiplier
+                // Movement speed modifier
+                val multiplier = if (slowDown) slowDownFactor else 1f
+
+                movementSideways = round(newX).toFloat() * multiplier
+                movementForward  = round(newZ).toFloat() * multiplier
             }
 
-            baritoneYaw ?: return
+            baritoneYaw ?: return@runSafe
 
             // Makes baritone movement safe
             // when yaw difference is too big to compensate it by modifying keyboard input

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

@@ -1,7 +1,6 @@
 package com.lambda.module.modules.movement
 
 import com.lambda.config.groups.IRotationConfig
-import com.lambda.event.events.MovementEvent
 import com.lambda.event.events.RotationEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listener
@@ -59,23 +58,10 @@ object TargetStrafe : Module(
             }
         }
 
-        listener<RotationEvent.Strafe> { event ->
-            targetEntity?.let {
-                event.strafeYaw = player.eyePos.rotationTo(it.boundingBox.center).yaw
-            }
-        }
-
-        listener<RotationEvent.Update> { event ->
-            targetEntity?.let {
-                event.context = RotationContext(
-                    player.eyePos.rotationTo(it.boundingBox.center),
-                    rotationConfig
-                )
-            }
-        }
-
-        listener<MovementEvent.InputUpdate> { event ->
+        listener<RotationEvent.StrafeInput> { event ->
             targetEntity?.let { target ->
+                event.strafeYaw = player.eyePos.rotationTo(target.boundingBox.center).yaw
+
                 val distSq = player.pos distSq target.pos
                 val keepRange = 0.5 * jitterCompensation
 
@@ -108,6 +94,15 @@ object TargetStrafe : Module(
             }
         }
 
+        listener<RotationEvent.Update> { event ->
+            targetEntity?.let {
+                event.context = RotationContext(
+                    player.eyePos.rotationTo(it.boundingBox.center),
+                    rotationConfig
+                )
+            }
+        }
+
         onEnable {
             targetEntity = null
             forwardDirection = 1