Freecam fixes:

Wrong sensitivity;
HitResult "NPE";
Rotation may override other modules

Author: bladekt

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

@@ -9,22 +9,22 @@ import com.lambda.event.events.RenderEvent
 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.slerp
 import com.lambda.interaction.rotation.Rotation.Companion.rotationTo
 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.KeyCode
 import com.lambda.util.player.MovementUtils.cancel
+import com.lambda.util.player.MovementUtils.verticalMovement
 import com.lambda.util.primitives.extension.interpolate
+import com.lambda.util.primitives.extension.partialTicks
 import com.lambda.util.primitives.extension.rotation
-import com.lambda.util.world.raycast.RayCastMask
-import com.lambda.util.world.raycast.RayCastUtils.rayCast
+import com.lambda.util.world.raycast.RayCastUtils.orMiss
+import com.lambda.util.world.raycast.RayCastUtils.orNull
 import net.minecraft.client.input.KeyboardInput
 import net.minecraft.entity.Entity
 import net.minecraft.util.math.Vec3d
-import kotlin.math.pow
 
 object Freecam : Module(
     name = "Freecam",
@@ -35,46 +35,46 @@ object Freecam : Module(
     private val speed by setting("Speed", 0.5f, 0.1f..1.0f, 0.1f)
     private val sprint by setting("Sprint Multiplier", 3.0f, 0.1f..10.0f, 0.1f, description = "Set below 1.0 to fly slower on sprint.")
     private val rotateToTarget by setting("Rotate to target", true)
+    private val reach by setting("Reach", 4.0, 1.0..100.0, 0.1)
 
     private val rotationConfig = RotationSettings(this).apply {
         rotationMode = RotationMode.LOCK
     }
 
     private var prevPosition: Vec3d = Vec3d.ZERO
-    @JvmStatic var position: Vec3d = Vec3d.ZERO
-    private val interpolatedPosition: Vec3d
-        get() = prevPosition.interpolate(position, mc.tickDelta.toDouble())
-
-    private var previousRotation: Rotation = Rotation.ZERO
-    @JvmStatic var rotation: Rotation = Rotation.ZERO
-    private val interpolatedRotation: Rotation
-        get() = previousRotation.slerp(rotation, mc.tickDelta.toDouble())
+    private var position: Vec3d = Vec3d.ZERO
+    private val interpolatedPosition: Vec3d get() =
+        prevPosition.interpolate(position, mc.partialTicks)
 
+    private var rotation: Rotation = Rotation.ZERO
     private var velocity: Vec3d = Vec3d.ZERO
 
     @JvmStatic fun updateCam() {
-        mc.gameRenderer.camera.apply {
-            setRotation(interpolatedRotation.yaw.toFloat(), interpolatedRotation.pitch.toFloat())
-            setPos(interpolatedPosition.x, interpolatedPosition.y, interpolatedPosition.z)
+        mc.gameRenderer.apply {
+            camera.setRotation(rotation.yawF, rotation.pitchF)
+            camera.setPos(interpolatedPosition.x, interpolatedPosition.y, interpolatedPosition.z)
         }
     }
 
     @JvmStatic fun updateRotation(deltaYaw: Double, deltaPitch: Double) {
-        previousRotation = rotation
-        val factor = (mc.options.mouseSensitivity.value * 0.6 + 0.2).pow(3)
-        rotation = rotation.withDelta(deltaYaw * factor, deltaPitch * factor)
+        rotation = rotation.withDelta(deltaYaw * SENSITIVITY_FACTOR, deltaPitch * SENSITIVITY_FACTOR)
     }
 
+    /**
+     * @see net.minecraft.entity.Entity.changeLookDirection
+     */
+    private const val SENSITIVITY_FACTOR = 0.15
+
     init {
         onEnable {
             position = player.eyePos
             rotation = player.rotation
             velocity = Vec3d.ZERO
         }
 
-        listener<RotationEvent.Pre> {
+        listener<RotationEvent.Pre>(Int.MAX_VALUE) {
             if (!rotateToTarget) return@listener
-            val target = mc.crosshairTarget ?: return@listener
+            val target = mc.crosshairTarget?.orNull ?: return@listener
 
             val rotation = player.eyePos.rotationTo(target.pos)
             it.context = RotationContext(rotation, rotationConfig)
@@ -90,30 +90,31 @@ object Freecam : Module(
             }
 
             // Create new input for freecam
-            val input = KeyboardInput(mc.options)
-            input.tick(event.slowDown, event.slowDownFactor)
-            var y = 0.0
-            if (input.jumping) y++
-            if (input.sneaking) y--
-            val inputVec = Vec3d(input.movementSideways.toDouble(), y, input.movementForward.toDouble())
+            val input = KeyboardInput(mc.options).apply {
+                tick(false, 1f)
+            }
+
+            val inputVec = Vec3d(
+                input.movementSideways.toDouble(),
+                verticalMovement.toDouble(),
+                input.movementForward.toDouble()
+            )
+
             val endSpeed = speed * if (mc.options.sprintKey.isPressed) sprint else 1.0f
             val velocityDelta = Entity.movementInputToVelocity(inputVec, endSpeed, rotation.yawF)
 
-            // move freecam
+            // Move freecam
             velocity = velocity.add(velocityDelta).multiply(0.6)
             prevPosition = position
             position = position.add(velocity)
         }
 
         listener<RenderEvent.UpdateTarget> {
             it.cancel()
-            mc.crosshairTarget = rayCast(
-                interpolatedPosition,
-                interpolatedRotation.vector,
-                interaction.reachDistance.toDouble(),
-                RayCastMask.BOTH,
-                true
-            )
+
+            mc.crosshairTarget = rotation
+                .rayCast(reach, eye = interpolatedPosition)
+                .orMiss // Can't be null (otherwise mc will spam "Null returned as 'hitResult', this shouldn't happen!")
         }
 
         listener<ConnectionEvent.Disconnect> {

common/src/main/kotlin/com/lambda/util/world/raycast/RayCastUtils.kt

@@ -1,5 +1,6 @@
 package com.lambda.util.world.raycast
 
+import com.lambda.Lambda.mc
 import com.lambda.context.SafeContext
 import com.lambda.interaction.rotation.Rotation
 import com.lambda.threading.runSafe
@@ -66,4 +67,10 @@ object RayCastUtils {
         if (type == HitResult.Type.MISS) return null
         return this as? BlockHitResult
     }
+
+    val HitResult.orNull get() = entityResult ?: blockResult
+
+    val HitResult?.orMiss get() = this ?: object : HitResult(mc.player?.eyePos ?: Vec3d.ZERO) {
+        override fun getType() = Type.MISS
+    }
 }