autocorrecting y motion obstacle passing and rubberbanding improvements when stopping flying

Author: beanbag44

src/main/kotlin/com/lambda/interaction/managers/rotating/RotationManager.kt

@@ -37,19 +37,14 @@ import com.lambda.interaction.managers.rotating.RotationManager.updateActiveRota
 import com.lambda.threading.runGameScheduled
 import com.lambda.threading.runSafe
 import com.lambda.util.extension.rotation
-import com.lambda.util.math.MathUtils.toRadian
 import com.lambda.util.math.Vec2d
 import com.lambda.util.math.lerp
+import com.lambda.util.player.RotationUtils.getInputRelativeTo
 import com.lambda.util.world.raycast.RayCastUtils.orMiss
 import net.minecraft.client.input.Input
 import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket
-import net.minecraft.util.PlayerInput
 import net.minecraft.util.hit.EntityHitResult
 import net.minecraft.util.math.Vec2f
-import kotlin.math.PI
-import kotlin.math.atan2
-import kotlin.math.cos
-import kotlin.math.sin
 
 /**
  * Manager designed to rotate the player and adjust movement input to match the camera's direction.
@@ -208,82 +203,19 @@ object RotationManager : Manager<RotationRequest>(
 	@JvmStatic
 	fun redirectStrafeInputs(input: Input) = runSafe {
 		val movementYaw = movementYaw ?: return@runSafe
-		val playerYaw = player.yaw
+		val viewYaw = player.yaw
 
-		if (movementYaw.minus(playerYaw).rem(360f).let { it * it } < 0.001f) return@runSafe
+		val newPlayerInput = getInputRelativeTo(movementYaw, input.playerInput, viewYaw)
 
-		val originalStrafe = input.movementVector.x
-		val originalForward = input.movementVector.y
-
-		if (originalStrafe == 0.0f && originalForward == 0.0f) return@runSafe
-
-		val deltaYawRad = (playerYaw - movementYaw).toRadian()
-
-		val cos = cos(deltaYawRad)
-		val sin = sin(deltaYawRad)
-		val newStrafe = originalStrafe * cos - originalForward * sin
-		val newForward = originalStrafe * sin + originalForward * cos
-
-		val angle = atan2(newStrafe.toDouble(), newForward.toDouble())
-
-		// Define the boundaries for our 8 sectors (in radians). Each sector is 45 degrees (PI/4).
-		val sector = (PI / 4.0).toFloat()
-		val boundary = (PI / 8.0).toFloat() // The halfway point between sectors (22.5 degrees)
-
-		var pressForward = false
-		var pressBackward = false
-		var pressLeft = false
-		var pressRight = false
-
-		// Determine which 45-degree sector the angle falls into and set the corresponding keys.
-		when {
-			angle > -boundary && angle <= boundary -> {
-				pressForward = true
-			}
-			angle > boundary && angle <= boundary + sector -> {
-				pressForward = true
-				pressLeft = true
-			}
-			angle > boundary + sector && angle <= boundary + 2 * sector -> {
-				pressLeft = true
-			}
-			angle > boundary + 2 * sector && angle <= boundary + 3 * sector -> {
-				pressBackward = true
-				pressLeft = true
-			}
-			angle > boundary + 3 * sector || angle <= -(boundary + 3 * sector) -> {
-				pressBackward = true
-			}
-			angle > -(boundary + 3 * sector) && angle <= -(boundary + 2 * sector) -> {
-				pressBackward = true
-				pressRight = true
-			}
-			angle > -(boundary + 2 * sector) && angle <= -(boundary + sector) -> {
-				pressRight = true
-			}
-			angle > -(boundary + sector) && angle <= -boundary -> {
-				pressForward = true
-				pressRight = true
-			}
-		}
-
-		input.playerInput = PlayerInput(
-			pressForward,
-			pressBackward,
-			pressLeft,
-			pressRight,
-			input.playerInput.jump(),
-			input.playerInput.sneak(),
-			input.playerInput.sprint()
-		)
+		input.playerInput = newPlayerInput
 
 		val x = multiplier(input.playerInput.left(), input.playerInput.right())
 		val y = multiplier(input.playerInput.forward(), input.playerInput.backward())
 		input.movementVector = Vec2f(x, y).normalize()
 	}
 
 	private fun multiplier(positive: Boolean, negative: Boolean) =
-		((if (positive) 1 else 0) - (if (negative) 1 else 0)).toFloat()
+		(if (positive) 1f else 0f) - (if (negative) 1f else 0f)
 
 	@JvmStatic fun onRotationSend() {
 		prevServerRotation = serverRotation
@@ -301,16 +233,16 @@ object RotationManager : Manager<RotationRequest>(
 	 */
 	private fun SafeContext.updateActiveRotation() {
 		val newYaw = yawRequest?.let { yawRequest ->
-			val toYaw = if (yawRequest.keepTicks >= 0)
-				yawRequest.yaw.value ?: activeRotation.yaw
-			else player.rotation.yaw
+			val toYaw =
+				if (yawRequest.keepTicks >= 0) yawRequest.yaw.value ?: activeRotation.yaw
+				else player.rotation.yaw
 			serverRotation.slerpYaw(toYaw, yawRequest.rotationConfig.turnSpeed)
 		} ?: player.rotation.yaw
 
 		val newPitch = pitchRequest?.let { pitchRequest ->
-			val toPitch = if (pitchRequest.keepTicks >= 0)
-				pitchRequest.pitch.value ?: activeRotation.pitch
-			else player.rotation.pitch
+			val toPitch =
+				if (pitchRequest.keepTicks >= 0) pitchRequest.pitch.value ?: activeRotation.pitch
+				else player.rotation.pitch
 			serverRotation.slerpPitch(toPitch, pitchRequest.rotationConfig.turnSpeed)
 		} ?: player.rotation.pitch
 
@@ -369,17 +301,15 @@ object RotationManager : Manager<RotationRequest>(
 
 	@JvmStatic
 	val movementYaw: Float?
-		get() {
-			return if (yawRequest == null || yawRequest?.rotationConfig?.rotationMode == RotationMode.Silent) null
+		get() =
+			if (yawRequest == null || yawRequest?.rotationConfig?.rotationMode == RotationMode.Silent) null
 			else activeRotation.yaw.toFloat()
-		}
 
 	@JvmStatic
 	val movementPitch: Float?
-		get() {
-			return if (pitchRequest == null || pitchRequest?.rotationConfig?.rotationMode == RotationMode.Silent) null
+		get() =
+			if (pitchRequest == null || pitchRequest?.rotationConfig?.rotationMode == RotationMode.Silent) null
 			else activeRotation.pitch.toFloat()
-		}
 
 	@JvmStatic
 	fun getRotationForVector(deltaTime: Double): Vec2d? = runSafe {

src/main/kotlin/com/lambda/module/modules/movement/elytrafly/ElytraFlyMode.kt

@@ -123,6 +123,8 @@ abstract class ElytraFlyMode(
 		return inventoryRequest.done
 	}
 
+	open fun interrupt() {}
+
 	fun SafeContext.findElytra(): Slot? =
 		ELYTRA_SELECTION.filterSlots(player.hotbarAndInventorySlots).minByOrNull { it.index }
 

src/main/kotlin/com/lambda/module/modules/movement/elytrafly/ObstaclePassingMode.kt

@@ -125,7 +125,7 @@ abstract class ObstaclePassingMode(
 		return false
 	}
 
-	private fun SafeContext.getSnappedDir(): Vec3d {
+	protected fun SafeContext.getSnappedDir(): Vec3d {
 		val travelDiff = player.pos.subtract(startPos).normalize().let { Vec3d(it.x, 0.0, it.z) }
 		return lockYawToStep(travelDiff)
 	}
@@ -150,24 +150,23 @@ abstract class ObstaclePassingMode(
 		return Vec3d(x, vector.y, z)
 	}
 
-	context(safeContext: SafeContext)
-	private fun pathToValidPoint(startSearchPos: Vec3d, dir: Vec3d, initialBlockedCheck: Boolean = false) {
+	private fun SafeContext.pathToValidPoint(startSearchPos: Vec3d, dir: Vec3d, initialBlockedCheck: Boolean = false) {
 		var skippingFirstCheck = !initialBlockedCheck
 		var searchPos = startSearchPos
 		while (skippingFirstCheck || searchPos.isObstructed(dir)) {
 			searchPos = searchPos.add(dir.multiply(passerConfig.obstacleLookAhead.toDouble()))
 			skippingFirstCheck = false
 		}
 		passTo(searchPos)
-		safeContext.player.stopGliding()
+		interrupt()
 	}
 
 	private fun passTo(pos: Vec3d) {
 		passingToPos = pos
 		BaritoneHandler.setGoalAndPath(GoalGetToBlock(pos.flooredBlockPos))
 	}
 
-	private fun Vec3d.findClosestPointOnLine(snappedDirection: Vec3d): Vec3d {
+	protected fun Vec3d.findClosestPointOnLine(snappedDirection: Vec3d): Vec3d {
 		val startToCurrent = subtract(startPos)
 		val t = startToCurrent.dotProduct(snappedDirection) / snappedDirection.dotProduct(snappedDirection)
 		return startPos.add(snappedDirection.multiply(t))

src/main/kotlin/com/lambda/module/modules/movement/elytrafly/modes/BounceElytraFly.kt

@@ -39,15 +39,23 @@ import com.lambda.util.PacketUtils.handlePacketSilently
 import com.lambda.util.PacketUtils.sendPacketSilently
 import com.lambda.util.SpeedUnit
 import com.lambda.util.TickTimer
+import com.lambda.util.math.distSq
+import com.lambda.util.math.minus
 import com.lambda.util.player.PlayerUtils.canStartGliding
 import com.lambda.util.player.PlayerUtils.canTakeoff
+import net.minecraft.client.input.KeyboardInput.getMovementMultiplier
 import net.minecraft.entity.Entity
 import net.minecraft.network.packet.Packet
 import net.minecraft.network.packet.s2c.common.CommonPingS2CPacket
+import net.minecraft.util.PlayerInput
+import net.minecraft.util.math.Vec2f
 import net.minecraft.util.math.Vec3d
 import java.util.*
 import java.util.concurrent.ConcurrentLinkedQueue
 import kotlin.math.abs
+import kotlin.math.cos
+import kotlin.math.pow
+import kotlin.math.sin
 
 class BounceElytraFly(
 	override val c: Config
@@ -69,33 +77,43 @@ class BounceElytraFly(
 	@Group(Y_MOTION_GROUP) val yMotionSetting by c.setting("Y Motion", false, "Cancels the players y velocity to aid speed")
 	@Group(Y_MOTION_GROUP) val onlyOnDiagonal: Boolean by c.setting("Only On Diagonal", true, "Only use y motion when the player is flying on a non-axial angle") { yMotionSetting }
 	@Group(Y_MOTION_GROUP) val minDiagonalAngle by c.setting("Min Diagonal Angle", 15.0, 0.0..180.0, 0.1, "The minimum angle the player must be flying to use y motion") { yMotionSetting && onlyOnDiagonal }
+	@Group(Y_MOTION_GROUP) val strictYMotionRange by c.setting("Strict Range", true, "provides an extra range check to sneak until within. Typically used for when you need to get within sub-block distances of walls for collision checks") { yMotionSetting }
+	@Group(Y_MOTION_GROUP) val acceptableYMotionRange by c.setting("Acceptable Range", 0.1, 0.01..5.0, 0.01, "The acceptable distance, aside from forward distance, from the start position") { yMotionSetting && strictYMotionRange }
 	@Group(Y_MOTION_GROUP) val yMotionStartSpeed by c.setting("Y Motion Start Speed", 30, 0..40, 1, unit = "bps") { yMotionSetting }
 	@Group(Y_MOTION_GROUP) val speedLimit by c.setting("Speed Limit", 110, 10..400, 1, unit = "bps") { yMotionSetting }
-	context(safeContext: SafeContext)
-	private val yMotion
+	private val SafeContext.yMotion
 		get() = yMotionSetting &&
-				(!onlyOnDiagonal || run {
-					val normalised = abs(RotationManager.activeRotation.yaw % 90)
-					normalised > minDiagonalAngle && normalised < 90 - minDiagonalAngle
-				}) &&
-				safeContext.player.isOnGround &&
-				safeContext.player.isGliding &&
+				onYMotionAngle &&
+				player.isOnGround &&
+				player.isGliding &&
 				Speedometer.calculateSpeed(true, SpeedUnit.BlocksPerSecond).let { speed ->
 					speed > yMotionStartSpeed && speed < speedLimit
 				}
 
+	private val onYMotionAngle
+		get() = !onlyOnDiagonal || diagonal
+
 	@Group(BOUNCE_OBSTACLE_PASSER_GROUP) override val passerConfig by c.configBlock(PasserSettings(c))
 
 	private var jumpThisTick = false
 	private var prevGliding: Boolean? = null
 	private val pauseTimer = TickTimer()
 	private val pingPackets = ConcurrentLinkedQueue<CommonPingS2CPacket>()
 	private val sendPacketQueue = LinkedList<Packet<*>>()
+	private var sneakLeft = false
+	private var sneakRight = false
+	private var interrupting = false
 
 	private val SafeContext.queuePackets
-		get() = fakeLag && player.isGliding && !yMotion &&
+		get() = fakeLag && player.isGliding && (!yMotionSetting || !onYMotionAngle) &&
 				player.y - startPos.y < if (passerConfig.passObstacles) passerConfig.minObstacleHeight + 0.1 else 0.163
 
+	private val diagonal: Boolean
+		get() {
+			val normalised = abs(RotationManager.activeRotation.yaw % 90)
+			return normalised > minDiagonalAngle && normalised < 90 - minDiagonalAngle
+		}
+
 	init {
 		listen<TickEvent.Pre> {
 			pauseTimer.tick()
@@ -104,12 +122,44 @@ class BounceElytraFly(
 
 			if (handlePassingObstacles()) return@listen
 
+			if (yMotionSetting && strictYMotionRange && onYMotionAngle && player.isOnGround) {
+				val snappedDir = getSnappedDir()
+				val closestLinePoint = player.pos.findClosestPointOnLine(snappedDir)
+				val xz = Vec3d(player.x, closestLinePoint.y, player.z)
+				if (xz distSq closestLinePoint > acceptableYMotionRange.pow(2)) {
+					if (player.isGliding) {
+						interrupt()
+						return@listen
+					}
+					val offset = player.pos - startPos
+					val cross = snappedDir.x * offset.z - snappedDir.z * offset.x
+					val rotationRequest = rotationRequest {
+						val yawAndPitch = snappedDir.yawAndPitch
+						yaw(yawAndPitch.y)
+					}.submit()
+					if (!rotationRequest.done) return@listen
+					sneakLeft = cross > 0
+					sneakRight = !sneakLeft
+					return@listen
+				}
+			}
+
 			if (!pauseTimer.hasSurpassed(flagPause)) return@listen
 
 			if (!player.isGliding) {
 				if (takeoff && player.canTakeoff) {
 					if (player.canStartGliding) GlideHandler.onGlide()
-					else jumpThisTick = true
+					else {
+						val yawRad = Math.toRadians(player.yaw.toDouble())
+						val rightX = -cos(yawRad)
+						val rightZ = -sin(yawRad)
+						val vx = player.velocity.x
+						val vz = player.velocity.z
+						val sidewaysSpeed = abs(vx * rightX + vz * rightZ)
+						if (sidewaysSpeed >= 0.001) return@listen
+
+						jumpThisTick = true
+					}
 				}
 				return@listen
 			}
@@ -119,9 +169,33 @@ class BounceElytraFly(
 			flyOrFakeFly()
 		}
 
+		listen<TickEvent.Post>({ -100 }) {
+			interrupting = false
+		}
+
 		listen<MovementEvent.InputUpdate> { event ->
-			if ((player.isGliding && jump) || jumpThisTick) {
-				event.input.jump()
+			val input = event.input
+			val playerInput = input.playerInput
+			if (sneakLeft || sneakRight) {
+				input.playerInput = PlayerInput(
+					playerInput.forward,
+					playerInput.backward,
+					sneakLeft,
+					sneakRight,
+					playerInput.jump,
+					true,
+					false
+				)
+				input.movementVector = Vec2f(
+					getMovementMultiplier(sneakLeft, sneakRight),
+					0f
+				)
+				sneakLeft = false
+				sneakRight = false
+				return@listen
+			}
+			if ((player.isGliding && !interrupting && jump) || jumpThisTick) {
+				input.jump()
 				jumpThisTick = false
 			}
 		}
@@ -145,11 +219,18 @@ class BounceElytraFly(
 		onFlag { pauseTimer.reset() }
 
 		onDisable {
+			jumpThisTick = false
 			prevGliding = false
 			flushPackets()
+			sneakLeft = false
+			sneakRight = false
 		}
 	}
 
+	override fun interrupt() {
+		interrupting = true
+	}
+
 	private fun SafeContext.flushPackets() {
 		while (sendPacketQueue.isNotEmpty()) {
 			val packet = sendPacketQueue.poll()
@@ -171,6 +252,7 @@ class BounceElytraFly(
 		runSafe {
 			val original: Boolean = player.getFlag(Entity.GLIDING_FLAG_INDEX)
 			if (prevGliding == true &&
+				!interrupting &&
 				pauseTimer.hasSurpassed(flagPause) &&
 				!BaritoneHandler.isActive) true
 			else {