Strafe rewrite rewrite rewrite (improved grim speed)

Author: bladekt

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

@@ -16,7 +16,7 @@ class RotationSettings(
     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() = abs(nextGaussian(mean, derivation))
+    override val turnSpeed get() = if (instant) 360.0 else abs(nextGaussian(mean, derivation))
 
     var speedMultiplier = 1.0
 

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

@@ -80,10 +80,6 @@ object RotationManager : Loadable {
         currentRotation = currentContext?.let { context ->
             val rotationTo = if (keepTicks >= 0) context.rotation else player.rotation
 
-            if (context.config.instant) {
-                return@let rotationTo
-            }
-
             var speedMultiplier = (context.config as? RotationSettings)?.speedMultiplier ?: 1.0
             if (keepTicks < 0) speedMultiplier = 1.0
 

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

@@ -1,20 +1,25 @@
 package com.lambda.module.modules.movement
 
-import com.lambda.config.groups.RotationSettings
+import com.lambda.config.groups.IRotationConfig
 import com.lambda.context.SafeContext
 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.rotation.Rotation
-import com.lambda.interaction.rotation.Rotation.Companion.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.player.MovementUtils.addSpeed
 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.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(
@@ -25,25 +30,34 @@ object Speed : Module(
     @JvmStatic val mode by setting("Mode", Mode.GRIM_STRAFE)
 
     // Grim
-    private val rotation = RotationSettings(this) { mode == Mode.GRIM_STRAFE }
+    private val grimEntityBoost by setting("Entity Boost", 1.0, 0.0..2.0, 0.01) { mode == Mode.GRIM_STRAFE }
+    private val grimCollideMultiplier by setting("Entity Collide Multiplier", 0.75, 0.0..1.0, 0.01)  { mode == Mode.GRIM_STRAFE && grimEntityBoost > 0.0}
+    private val grimBoatBoost by setting("Boat Boost", 0.4, 0.0..1.0, 0.01) { mode == Mode.GRIM_STRAFE }
 
     // NCP
-    private val ncpBaseSpeed by setting("Base Speed", 0.2873, 0.1..0.3, 0.0001, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpMaxSpeed by setting("Max Speed", 1.0, 0.3..1.0, 0.0001, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpDecay by setting("Decay", 0.9937, 0.98..1.0, 0.0001, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpJumpSpeed by setting("Jump Speed", 0.3, 0.0..0.5, 0.001, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpJumpDecay by setting("Jump Decay", 0.59, 0.1..1.0, 0.0001, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpJumpHeight by setting("Jump Height", 0.4, 0.1..0.5, 0.00001, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpResetOnJump by setting("Reset On Jump", true, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpAutoJump by setting("Auto Jump", false, visibility = { mode == Mode.NCP_STRAFE })
-    private val ncpTimerBoost by setting("Timer Boost", 1.08, 1.0..1.1, 0.01, visibility = { mode == Mode.NCP_STRAFE })
+    private val strict by setting("Strict", true) { mode == Mode.NCP_STRAFE }
+    private val lowerJump by setting("Lower Jump", true) { mode == Mode.NCP_STRAFE }
+    private val ncpAutoJump by setting("Auto Jump", false) { mode == Mode.NCP_STRAFE }
+    private val ncpTimerBoost by setting("Timer Boost", 1.08, 1.0..1.1, 0.01) { mode == Mode.NCP_STRAFE }
 
     // Grim
-    private var desiredRotation = Rotation.ZERO
+    private var desiredRotation: Rotation? = null
+    private val rotationConfig = object : IRotationConfig {
+        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 ncpSpeed = ncpBaseSpeed
+    private var ncpSpeed = NCP_BASE_SPEED
     private var lastDistance = 0.0
 
     enum class Mode {
@@ -66,32 +80,31 @@ object Speed : Module(
                 desiredRotation = if (dx != 0 || dy != 0) {
                     val angle = Math.toDegrees(atan2(dy.toDouble(), dx.toDouble()))
                     Rotation(player.yaw + angle.toFloat(), player.pitch)
-                } else {
-                    Rotation.ZERO
-                }
+                } else null
             }
         }
 
-        listener<RotationEvent.Pre> {
+        listener<RotationEvent.Pre> { event ->
             if (!shouldWork()) return@listener
             if (mode != Mode.GRIM_STRAFE) return@listener
-            if (desiredRotation == Rotation.ZERO) return@listener
 
-            it.context = RotationContext(
-                desiredRotation,
-                rotation
-            )
+            desiredRotation?.let { rot ->
+                event.context = RotationContext(
+                    rot,
+                    rotationConfig
+                )
+            }
         }
 
         listener<MovementEvent.Pre> {
             if (!shouldWork()) {
-                ncpSpeed = ncpBaseSpeed
+                ncpSpeed = NCP_BASE_SPEED
                 return@listener
             }
 
             when (mode) {
-                Mode.NCP_STRAFE -> handleStrafe()
                 Mode.GRIM_STRAFE -> handleGrim()
+                Mode.NCP_STRAFE -> handleStrafe()
             }
         }
 
@@ -110,18 +123,40 @@ object Speed : Module(
 
             when (mode) {
                 Mode.NCP_STRAFE -> it.cancel()
-                Mode.GRIM_STRAFE -> {}
+                else -> {}
             }
         }
 
         onEnable {
             ncpPhase = NCPPhase.SLOWDOWN
-            ncpSpeed = ncpBaseSpeed
+            ncpSpeed = NCP_BASE_SPEED
         }
     }
 
     private fun SafeContext.handleGrim() {
+        if (!isInputting) return
+
+        var boostAmount = 0.0
 
+        getFastEntities<LivingEntity>(
+            player.pos, 3.0,
+            predicate = { player.boundingBox.expand(1.0) in it.boundingBox },
+            iterator = { e, _ ->
+                val colliding = player.boundingBox in e.boundingBox
+                val multiplier = if (colliding) grimCollideMultiplier else 1.0
+                boostAmount += 0.08 * grimEntityBoost * multiplier
+            }
+        )
+
+        if (grimBoatBoost > 0.0) {
+            getFastEntities<BoatEntity>(
+                player.pos, 4.0,
+                predicate = { player.boundingBox in it.boundingBox.expand(0.01) },
+                iterator = { _, _ -> boostAmount += grimBoatBoost }
+            )
+        }
+
+        addSpeed(boostAmount)
     }
 
     private fun SafeContext.handleStrafe() {
@@ -134,35 +169,33 @@ object Speed : Module(
         ncpPhase = when (ncpPhase) {
             NCPPhase.JUMP -> {
                 if (player.isOnGround) {
-                    if (ncpResetOnJump) ncpSpeed = ncpBaseSpeed
-
-                    player.motionY = ncpJumpHeight
-                    ncpSpeed += ncpJumpSpeed
+                    player.motionY = if (lowerJump) 0.4 else 0.42
+                    ncpSpeed = NCP_BASE_SPEED + 0.3
                     NCPPhase.JUMP_POST
                 } else NCPPhase.SLOWDOWN
             }
 
             NCPPhase.JUMP_POST -> {
-                ncpSpeed *= ncpJumpDecay
+                ncpSpeed *= if (strict) 0.59 else 0.62
                 NCPPhase.SLOWDOWN
             }
 
             NCPPhase.SLOWDOWN -> {
-                ncpSpeed = lastDistance * ncpDecay
+                ncpSpeed = lastDistance * NCP_AIR_DECAY
                 NCPPhase.SLOWDOWN
             }
         }
 
         if (player.isOnGround && !shouldJump) {
-            ncpSpeed = ncpBaseSpeed
+            ncpSpeed = NCP_BASE_SPEED
         }
 
         ncpSpeed = ncpSpeed
-            .coerceAtMost(ncpMaxSpeed)
-            .coerceAtLeast(ncpBaseSpeed)
+            .coerceAtMost(1.0)
+            .coerceAtLeast(NCP_BASE_SPEED)
 
         val moveSpeed = if (isInputting) ncpSpeed else {
-            ncpSpeed = ncpBaseSpeed
+            ncpSpeed = NCP_BASE_SPEED
             0.0
         }
 

common/src/main/kotlin/com/lambda/util/primitives/extension/Box.kt

@@ -5,4 +5,6 @@ import net.minecraft.util.math.Vec3d
 
 val Box.min get() = Vec3d(minX, minY, minZ)
 
-val Box.max get() = Vec3d(maxX, maxY, maxZ)
+val Box.max get() = Vec3d(maxX, maxY, maxZ)
+
+operator fun Box.contains(boundingBox: Box) = this.intersects(boundingBox)