Rotation, Speed refactor

Author: bladekt

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

@@ -4,7 +4,6 @@ import com.lambda.interaction.rotation.RotationMode
 
 interface IRotationConfig {
     /**
-     * - [RotationMode.NONE] No rotation.
      * - [RotationMode.SILENT] Spoofing server-side rotation.
      * - [RotationMode.SYNC] Spoofing server-side rotation and adjusting client-side movement based on reported rotation (for Grim).
      * - [RotationMode.LOCK] Locks the camera client-side.
@@ -26,20 +25,9 @@ interface IRotationConfig {
      */
     val resetTicks: Int
 
-    /**
-     * If true, rotation will be instant without any transition. If false, rotation will transition over time.
-     */
-    val instant: Boolean
-
-    /**
-     * The mean (average) value for the Gaussian distribution used to calculate rotation speed.
-     * This value represents the center of the distribution.
-     */
-    val mean: Double
-
-    /**
-     * The standard deviation for the Gaussian distribution used to calculate rotation speed.
-     * This value represents the spread or dispersion of the distribution.
-     */
-    val derivation: Double
+    interface Instant : IRotationConfig {
+        override val turnSpeed get() = 360.0
+        override val keepTicks get() = 1
+        override val resetTicks get() = 1
+    }
 }

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

@@ -9,25 +9,59 @@ class RotationSettings(
     c: Configurable,
     vis: () -> Boolean = { true },
 ) : IRotationConfig {
-    override var rotationMode by c.setting("Mode", RotationMode.SYNC, "SILENT - server-side rotation, SYNC - server-side rotation; client-side movement, LOCK - Lock camera", vis)
+    override var rotationMode by c.setting(
+        "Mode",
+        RotationMode.SYNC,
+        "SILENT - server-side rotation, SYNC - server-side rotation; client-side movement, LOCK - Lock camera",
+        vis
+    )
+
     override val keepTicks by c.setting("Keep Rotation", 3, 1..10, 1, "Ticks to keep rotation", " ticks", vis)
     override val resetTicks by c.setting("Reset Rotation", 3, 1..10, 1, "Ticks before rotation is reset", " ticks", vis)
-    override var instant by c.setting("Instant Rotation", true, "Instantly rotate", vis)
-    override var mean by c.setting("Mean", 20.0, 1.0..80.0, 0.1, "Average rotation speed", unit = "°") { vis() && !instant }
-    override var derivation by c.setting("Standard Deviation", 5.0, 0.0..20.0, 0.1, "Spread of rotation speeds", unit = "°") { vis() && !instant }
 
-    override val turnSpeed get() = if (instant) 360.0 else abs(nextGaussian(mean, derivation))
+    /**
+     * 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)
+
+    /**
+     * The mean (average/base) value used to calculate rotation speed.
+     * This value represents the center of the distribution.
+     */
+    private var mean by c.setting(
+        "Mean",
+        40.0,
+        1.0..120.0,
+        0.1,
+        "Average rotation speed",
+        unit = "°"
+    ) { vis() && !instant }
+
+    /**
+     * The standard deviation for the Gaussian distribution used to calculate rotation speed.
+     * This value represents the spread of rotation speed.
+     */
+    private var spread by c.setting(
+        "Spread",
+        10.0,
+        0.0..60.0,
+        0.1,
+        "Spread of rotation speeds",
+        unit = "°"
+    ) { vis() && !instant }
+
+    /**
+     * We always have to pass turn speed to the interpolator, because player's yaw could be out of -180..180 range and
+     * Thus we cant simply assign new angles to the player's rotation without getting flagged by Grim's AimModulo360 check
+     */
+    override val turnSpeed get() = if (instant) 180.0 else abs(mean + spread * nextRandom())
 
     var speedMultiplier = 1.0
 
-    private fun nextGaussian(
-        mean: Double = 0.0,
-        deviation: Double = 1.0
-    ): Double {
+    private fun nextRandom(): Double {
         val u1 = Random.nextDouble()
         val u2 = Random.nextDouble()
 
-        val randStdNormal = sqrt(-2.0 * ln(u1)) * cos(2.0 * PI * u2)
-        return mean + deviation * randStdNormal
+        return sqrt(-2.0 * ln(u1)) * cos(2.0 * PI * u2)
     }
 }

common/src/main/kotlin/com/lambda/gui/impl/clickgui/buttons/setting/EnumSlider.kt

@@ -7,12 +7,12 @@ import com.lambda.gui.impl.clickgui.buttons.ModuleButton
 import com.lambda.gui.impl.clickgui.buttons.SettingButton
 import com.lambda.module.modules.client.ClickGui
 import com.lambda.util.math.ColorUtils.setAlpha
+import com.lambda.util.math.MathUtils.floorToInt
 import com.lambda.util.math.MathUtils.lerp
 import com.lambda.util.math.Vec2d
 import com.lambda.util.math.transform
 import com.lambda.util.primitives.extension.displayValue
 import java.awt.Color
-import kotlin.math.floor
 
 class EnumSlider<T : Enum<T>>(
     setting: EnumSetting<T>,
@@ -43,7 +43,7 @@ class EnumSlider<T : Enum<T>>(
     }
 
     override fun setValueByProgress(progress: Double) {
-        val entryIndex = floor(progress * enumSize).toInt().coerceIn(0, enumSize - 1)
+        val entryIndex = (progress * enumSize).floorToInt().coerceIn(0, enumSize - 1)
         value = values[entryIndex]
         valueSetByDrag = true
     }

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

@@ -1,13 +1,11 @@
 package com.lambda.interaction.rotation
 
 /**
- * @property NONE No rotation.
  * @property SILENT Spoofing server-side rotation.
  * @property SYNC Spoofing server-side rotation and adjusting client-side movement based on reported rotation (for Grim).
  * @property LOCK Locks the camera client-side.
  */
 enum class RotationMode {
-    NONE,
     SILENT,
     SYNC,
     LOCK

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

@@ -6,28 +6,37 @@ import com.lambda.event.events.ClientEvent
 import com.lambda.event.events.MovementEvent
 import com.lambda.event.events.RotationEvent
 import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.interaction.RotationManager
 import com.lambda.interaction.rotation.Rotation
 import com.lambda.interaction.rotation.RotationContext
 import com.lambda.interaction.rotation.RotationMode
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
+import com.lambda.util.Nameable
 import com.lambda.util.player.MovementUtils.addSpeed
+import com.lambda.util.player.MovementUtils.calcMoveYaw
 import com.lambda.util.player.MovementUtils.isInputting
 import com.lambda.util.player.MovementUtils.motionY
 import com.lambda.util.player.MovementUtils.moveDelta
+import com.lambda.util.player.MovementUtils.newMovementInput
+import com.lambda.util.player.MovementUtils.roundedForward
+import com.lambda.util.player.MovementUtils.roundedStrafing
 import com.lambda.util.player.MovementUtils.setSpeed
 import com.lambda.util.primitives.extension.contains
 import com.lambda.util.world.WorldUtils.getFastEntities
 import net.minecraft.entity.LivingEntity
 import net.minecraft.entity.vehicle.BoatEntity
-import kotlin.math.atan2
 
 object Speed : Module(
     name = "Speed",
     description = "Accelerates your walking speed",
     defaultTags = setOf(ModuleTag.MOVEMENT)
 ) {
-    @JvmStatic val mode by setting("Mode", Mode.GRIM_STRAFE)
+    @JvmStatic val mode by setting("Mode", Mode.GRIM_STRAFE).apply {
+        onValueChange { _, _ ->
+            reset()
+        }
+    }
 
     // Grim
     private val grimEntityBoost by setting("Entity Boost", 1.0, 0.0..2.0, 0.01) { mode == Mode.GRIM_STRAFE }
@@ -41,28 +50,21 @@ object Speed : Module(
     private val ncpTimerBoost by setting("Timer Boost", 1.08, 1.0..1.1, 0.01) { mode == Mode.NCP_STRAFE }
 
     // Grim
-    private var desiredRotation: Rotation? = null
-    private val rotationConfig = object : IRotationConfig {
+    private val rotationConfig = object : IRotationConfig.Instant {
         override val rotationMode = RotationMode.SYNC
-        override val turnSpeed = 360.0
-        override val keepTicks = 1
-        override val resetTicks = 1
-        override val instant = true
-        override val mean = 180.0
-        override val derivation = 1.0
     }
 
     // NCP
     private const val NCP_BASE_SPEED = 0.2873
     private const val NCP_AIR_DECAY = 0.9937
 
-    private var ncpPhase = NCPPhase.JUMP
+    private var ncpPhase = NCPPhase.SLOWDOWN
     private var ncpSpeed = NCP_BASE_SPEED
     private var lastDistance = 0.0
 
-    enum class Mode {
-        GRIM_STRAFE,
-        NCP_STRAFE,
+    enum class Mode(override val displayName: String) : Nameable.NamedEnum {
+        GRIM_STRAFE("Grim Strafe"),
+        NCP_STRAFE("NCP Strafe"),
     }
 
     private enum class NCPPhase {
@@ -72,33 +74,9 @@ object Speed : Module(
     }
 
     init {
-        listener<MovementEvent.InputUpdate> {
-            it.input.let { input ->
-                val dx = if (input.pressingForward) 1 else if (input.pressingBack) -1 else 0
-                val dy = if (input.pressingRight) 1 else if (input.pressingLeft) -1 else 0
-
-                desiredRotation = if (dx != 0 || dy != 0) {
-                    val angle = Math.toDegrees(atan2(dy.toDouble(), dx.toDouble()))
-                    Rotation(player.yaw + angle.toFloat(), player.pitch)
-                } else null
-            }
-        }
-
-        listener<RotationEvent.Pre> { event ->
-            if (!shouldWork()) return@listener
-            if (mode != Mode.GRIM_STRAFE) return@listener
-
-            desiredRotation?.let { rot ->
-                event.context = RotationContext(
-                    rot,
-                    rotationConfig
-                )
-            }
-        }
-
         listener<MovementEvent.Pre> {
             if (!shouldWork()) {
-                ncpSpeed = NCP_BASE_SPEED
+                reset()
                 return@listener
             }
 
@@ -113,8 +91,8 @@ object Speed : Module(
         }
 
         listener<ClientEvent.Timer> {
-            if (!shouldWork() || !isInputting) return@listener
             if (mode != Mode.NCP_STRAFE) return@listener
+            if (!shouldWork() || !isInputting) return@listener
             it.speed = ncpTimerBoost
         }
 
@@ -127,9 +105,20 @@ object Speed : Module(
             }
         }
 
+        listener<RotationEvent.Update> { event ->
+            if (mode != Mode.GRIM_STRAFE) return@listener
+            if (!shouldWork() || !isInputting) return@listener
+
+            val input = newMovementInput()
+            val moveYaw = RotationManager.BaritoneProcessor.baritoneContext?.rotation?.yawF ?: player.yaw
+            val yaw = calcMoveYaw(moveYaw, input.roundedForward, input.roundedStrafing)
+            val rotation = Rotation(yaw, event.context?.rotation?.pitch ?: player.pitch.toDouble())
+
+            event.context = RotationContext(rotation, rotationConfig)
+        }
+
         onEnable {
-            ncpPhase = NCPPhase.SLOWDOWN
-            ncpSpeed = NCP_BASE_SPEED
+            reset()
         }
     }
 
@@ -208,4 +197,9 @@ object Speed : Module(
                 && !player.input.sneaking
                 && !player.isTouchingWater
                 && !player.isInLava
+
+    private fun reset() {
+        ncpPhase = NCPPhase.SLOWDOWN
+        ncpSpeed = NCP_BASE_SPEED
+    }
 }

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

@@ -2,7 +2,7 @@ package com.lambda.module.modules.player
 
 import com.google.gson.*
 import com.lambda.brigadier.CommandResult
-import com.lambda.config.groups.RotationSettings
+import com.lambda.config.groups.IRotationConfig
 import com.lambda.context.SafeContext
 import com.lambda.core.TimerManager
 import com.lambda.event.EventFlow.lambdaScope
@@ -60,10 +60,10 @@ object Replay : Module(
     private val velocityCheck by setting("Velocity check", true, description = "Check if the player is moving before starting a recording.")
     private val cancelOnDeviation by setting("Cancel on deviation", true)
     private val deviationThreshold by setting("Deviation threshold", 0.1, 0.1..5.0, 0.1, description = "The threshold for the deviation to cancel the replay.") { cancelOnDeviation }
+    private val lockCamera by setting("Lock Camera", true)
 
-    private val rotationConfig = RotationSettings(this).apply {
-        rotationMode = RotationMode.LOCK
-        instant = true
+    private val rotationConfig = object : IRotationConfig.Instant {
+        override val rotationMode = if (lockCamera) RotationMode.LOCK else RotationMode.SYNC
     }
 
     enum class State {
@@ -140,7 +140,7 @@ object Replay : Module(
             }
         }
 
-        listener<RotationEvent.Pre> { event ->
+        listener<RotationEvent.Update> { event ->
             when (state) {
                 State.RECORDING -> {
                     buffer?.rotation?.add(player.rotation)

common/src/main/kotlin/com/lambda/util/Nameable.kt

@@ -5,4 +5,8 @@ package com.lambda.util
  */
 interface Nameable {
     val name: String
+
+    interface NamedEnum {
+        val displayName: String
+    }
 }