fix rotations timing issue

Author: beanbag44

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

@@ -74,6 +74,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.processRotations();
         RotationManager.BaritoneProcessor.processPlayerMovement(input, slowDown, slowDownFactor);
         EventFlow.post(new MovementEvent.InputUpdate(input, slowDown, slowDownFactor));
     }

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

@@ -23,7 +23,6 @@ import com.lambda.core.Loadable
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.ConnectionEvent
 import com.lambda.event.events.PacketEvent
-import com.lambda.event.events.PlayerPacketEvent
 import com.lambda.event.events.RotationEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.events.UpdateManagerEvent
@@ -80,69 +79,68 @@ object RotationManager : RequestHandler<RotationRequest>(), Loadable {
     }
 
     init {
-        // For some reason we have to update AFTER sending player packets
-        // instead of updating on TickEvent.Pre (am I doing something wrong?)
-        listen<PlayerPacketEvent.Post>(Int.MIN_VALUE) {
-            preEvent()
-
-            // Update the request
-            val changed = updateRequest(true) { entry ->
-                // skip requests that have failed to build the rotation
-                // to free the request place for others
-                entry.value.target.targetRotation.value != null
-            }
-
-            if (currentRequest != null) activeThisTick = true
+        listen<PacketEvent.Send.Post> { event ->
+            val packet = event.packet
+            if (packet !is PlayerPositionLookS2CPacket) return@listen
 
-            if (!changed) { // rebuild the rotation if the same context gets used again
-                currentRequest?.target?.targetRotation?.update()
+            runGameScheduled {
+                reset(Rotation(packet.yaw, packet.pitch))
             }
+        }
 
-            // Calculate the target rotation
-            val targetRotation = currentRequest?.let { request ->
-                val rotationTo = if (request.keepTicks >= 0)
-                    request.target.targetRotation.value
-                        ?: currentRotation // same context gets used again && the rotation is null this tick
-                else player.rotation
+        listenUnsafe<ConnectionEvent.Connect.Pre> {
+            reset(Rotation.ZERO)
+        }
+    }
 
-                val speedMultiplier = if (request.keepTicks < 0) 1.0 else request.speedMultiplier
-                val turnSpeed = request.turnSpeed() * speedMultiplier
+    @JvmStatic
+    fun processRotations() = runSafe {
+        preEvent()
+
+        // Update the request
+        val changed = updateRequest(true) { entry ->
+            // skip requests that have failed to build the rotation
+            // to free the request place for others
+            entry.value.target.targetRotation.value != null
+        }
 
-                currentRotation.slerp(rotationTo, turnSpeed)
-            } ?: player.rotation
+        if (currentRequest != null) activeThisTick = true
 
-            // Update the current rotation
-            prevRotation = currentRotation
-            currentRotation = targetRotation/*.fixSensitivity(prevRotation)*/
+        if (!changed) { // rebuild the rotation if the same context gets used again
+            currentRequest?.target?.targetRotation?.update()
+        }
 
-            // Handle LOCK mode
-            if (currentRequest?.mode == RotationMode.Lock) {
-                player.yaw = currentRotation.yawF
-                player.pitch = currentRotation.pitchF
-            }
+        // Calculate the target rotation
+        val targetRotation = currentRequest?.let { request ->
+            val rotationTo = if (request.keepTicks >= 0)
+                request.target.targetRotation.value
+                    ?: currentRotation // same context gets used again && the rotation is null this tick
+            else player.rotation
 
-            // Tick and reset the context
-            currentRequest?.let {
-                if (--it.keepTicks > 0) return@let
-                if (--it.decayTicks >= 0) return@let
-                currentRequest = null
-            }
+            val speedMultiplier = if (request.keepTicks < 0) 1.0 else request.speedMultiplier
+            val turnSpeed = request.turnSpeed() * speedMultiplier
 
-            postEvent()
-        }
+            currentRotation.slerp(rotationTo, turnSpeed)
+        } ?: player.rotation
 
-        listen<PacketEvent.Send.Post> { event ->
-            val packet = event.packet
-            if (packet !is PlayerPositionLookS2CPacket) return@listen
+        // Update the current rotation
+        prevRotation = currentRotation
+        currentRotation = targetRotation/*.fixSensitivity(prevRotation)*/
 
-            runGameScheduled {
-                reset(Rotation(packet.yaw, packet.pitch))
-            }
+        // Handle LOCK mode
+        if (currentRequest?.mode == RotationMode.Lock) {
+            player.yaw = currentRotation.yawF
+            player.pitch = currentRotation.pitchF
         }
 
-        listenUnsafe<ConnectionEvent.Connect.Pre> {
-            reset(Rotation.ZERO)
+        // Tick and reset the context
+        currentRequest?.let {
+            if (--it.keepTicks > 0) return@let
+            if (--it.decayTicks >= 0) return@let
+            currentRequest = null
         }
+
+        postEvent()
     }
 
     private fun reset(rotation: Rotation) {