obstacle passer in ElytraFly for mode Bounce

beanbag44 · beanbag44 · commit 30c6deb60c12 · 2026-04-26T04:08:29.000+01:00
diff --git a/src/main/java/com/lambda/mixin/network/ClientPlayNetworkHandlerMixin.java b/src/main/java/com/lambda/mixin/network/ClientPlayNetworkHandlerMixin.java
@@ -17,18 +17,22 @@
 
 package com.lambda.mixin.network;
 
+import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.ChatEvent;
 import com.lambda.event.events.InventoryEvent;
 import com.lambda.event.events.WorldEvent;
 import com.lambda.interaction.managers.inventory.InventoryManager;
 import com.lambda.module.modules.movement.Velocity;
+import com.lambda.module.modules.player.NoForceRotate;
 import com.lambda.module.modules.render.NoRender;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.client.network.ClientPlayNetworkHandler;
 import net.minecraft.client.network.PlayerListEntry;
+import net.minecraft.entity.Entity;
 import net.minecraft.network.packet.s2c.play.*;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -132,4 +136,26 @@ void onOverlayMessage(OverlayMessageS2CPacket packet, CallbackInfo ci) {
             ci.cancel();
         }
     }
+
+    @ModifyExpressionValue(method = "setPosition(Lnet/minecraft/entity/EntityPosition;Ljava/util/Set;Lnet/minecraft/entity/Entity;Z)Z", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/EntityPosition;yaw()F"))
+    private static float wrapSetYaw(float original, @Local(argsOnly = true) Entity entity) {
+        var player = Lambda.getMc().player;
+        if (entity != player) return original;
+        if (player == null) return original;
+        if (NoForceRotate.INSTANCE.isEnabled()) {
+            return player.getYaw();
+        }
+        return original;
+    }
+
+    @ModifyExpressionValue(method = "setPosition(Lnet/minecraft/entity/EntityPosition;Ljava/util/Set;Lnet/minecraft/entity/Entity;Z)Z", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/EntityPosition;pitch()F"))
+    private static float wrapSetPitch(float original, @Local(argsOnly = true) Entity entity) {
+        var player = Lambda.getMc().player;
+        if (entity != player) return original;
+        if (player == null) return original;
+        if (NoForceRotate.INSTANCE.isEnabled()) {
+            return player.getPitch();
+        }
+        return original;
+    }
 }
diff --git a/src/main/kotlin/com/lambda/module/modules/movement/ElytraFly.kt b/src/main/kotlin/com/lambda/module/modules/movement/ElytraFly.kt
@@ -17,6 +17,7 @@
 
 package com.lambda.module.modules.movement
 
+import baritone.api.pathing.goals.GoalGetToBlock
 import com.lambda.config.AutomationConfig.Companion.setDefaultAutomationConfig
 import com.lambda.config.applyEdits
 import com.lambda.context.SafeContext
@@ -25,7 +26,9 @@ import com.lambda.event.events.MovementEvent
 import com.lambda.event.events.PacketEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.interaction.BaritoneManager
 import com.lambda.interaction.managers.rotating.IRotationRequest.Companion.rotationRequest
+import com.lambda.interaction.material.StackSelection.Companion.select
 import com.lambda.module.Module
 import com.lambda.module.modules.movement.BetterFirework.canOpenElytra
 import com.lambda.module.modules.movement.BetterFirework.canTakeoff
@@ -35,12 +38,18 @@ import com.lambda.threading.runSafe
 import com.lambda.util.Timer
 import com.lambda.util.extension.isElytraFlying
 import com.lambda.util.player.MovementUtils.addSpeed
-import com.lambda.util.player.SlotUtils.hotbarAndInventoryStacks
 import com.lambda.util.player.SlotUtils.hotbarStacks
 import com.lambda.util.player.hasFirework
-import com.lambda.interaction.material.StackSelection.Companion.selectStack
 import com.lambda.module.hud.Speedometer
+import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.SpeedUnit
+import com.lambda.util.math.dist
+import com.lambda.util.math.flooredBlockPos
+import com.lambda.util.math.isLoaded
+import com.lambda.util.player.SlotUtils.inventoryStacks
+import com.lambda.util.world.raycast.InteractionMask
+import com.lambda.util.world.raycast.RayCastUtils.blockResult
+import com.lambda.util.world.raycast.RayCastUtils.rayCast
 import net.minecraft.component.DataComponentTypes
 import net.minecraft.entity.Entity
 import net.minecraft.item.ItemStack
@@ -49,6 +58,13 @@ import net.minecraft.network.packet.c2s.play.ClientCommandC2SPacket
 import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket
 import net.minecraft.sound.SoundEvents
 import net.minecraft.util.math.Vec3d
+import java.lang.Math.toDegrees
+import java.lang.Math.toRadians
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.hypot
+import kotlin.math.roundToInt
+import kotlin.math.sin
 import kotlin.time.Duration.Companion.seconds
 
 object ElytraFly : Module(
@@ -57,35 +73,42 @@ object ElytraFly : Module(
     tag = ModuleTag.MOVEMENT,
 ) {
     @JvmStatic val mode by setting("Mode", FlyMode.Bounce)
+
     private val inventory by setting("Inventory", true, "Allow using fireworks from the players inventory") { mode == FlyMode.GrimControl }
 
     //ToDo: Implement these commented out settings
     private val takeoff by setting("Takeoff", true, "Automatically jumps and initiates gliding") { mode == FlyMode.Bounce }
     private val autoPitch by setting("Auto Pitch", true, "Automatically pitches the players rotation down to bounce at faster speeds") { mode == FlyMode.Bounce }
-    private val pitch by setting("Pitch", 80, 0..90, 1) { autoPitch && mode == FlyMode.Bounce }
+    private val pitch by setting("Pitch", 80, 0..90, 1) { mode == FlyMode.Bounce && autoPitch }
     private val yMotion by setting("Y Motion", false, "Cancels the players y velocity to aid speed") { mode == FlyMode.Bounce }
-    private val yMotionStartSpeed by setting("Y Motion Start Speed", 30, 5..30, 1, "bps") { mode == FlyMode.Bounce && yMotion }
-    private val speedLimit by setting("Speed Limit", 110, 10..720, 1, "bps") { mode == FlyMode.Bounce && yMotion }
+    private val yMotionStartSpeed by setting("Y Motion Start Speed", 30, 5..40, 1, "bps") { mode == FlyMode.Bounce && yMotion }
+    private val speedLimit by setting("Speed Limit", 110, 10..400, 1, "bps") { mode == FlyMode.Bounce && yMotion }
     private val jump by setting("Jump", true, "Automatically jumps") { mode == FlyMode.Bounce }
-    private val flagPause by setting("Flag Pause", 20, 0..100, 1, "How long to pause if the server flags you for a movement check") { mode == FlyMode.Bounce }
-//    private val passObstacles by setting("Pass Obstacles", true, "Automatically paths around obstacles using baritone") { mode == FlyMode.Bounce }
+    private val flagPause by setting("Flag Pause", 5, 0..100, 1, "How long to pause if the server flags you for a movement check", "ticks") { mode == FlyMode.Bounce }
+    private val passObstacles by setting("Pass Obstacles", true, "Automatically paths around obstacles using baritone") { mode == FlyMode.Bounce }
+    private val acceptableOffsetRange by setting("Acceptable Offset Range", 2.0, 0.1..5.0, 0.01, "Acceptable offset from the original flight line to allow when starting to fly again after passing obstacles") { mode == FlyMode.Bounce && passObstacles }
+    private val obstacleLookAhead by setting("Obstacle Look-Ahead", 15, 0..50, 1, "Looks ahead of the player to see if obstacles are in the way") { mode == FlyMode.Bounce && passObstacles }
+    private val directionStep by setting("Direction Step", 45.0, 0.0..180.0, 0.1, "The step size to use when locking the flight direction") { mode == FlyMode.Bounce && passObstacles }
 
     private val boostSpeed by setting("Boost", 0.00, 0.0..0.5, 0.005, description = "Speed to add when flying")
     private val rocketSpeed by setting("Rocket Speed", 0.0, 0.0..2.0, description = "Speed multiplier that the rocket gives you") { mode == FlyMode.Enhanced }
 
     private val mute by setting("Mute Elytra", false, "Mutes the elytra sound when gliding")
 
+    private var startPos = Vec3d.ZERO
     private var jumpThisTick = false
     private var previouslyFlying: Boolean? = null
+    private var passingToPos: Vec3d? = null
     private var glidePause = 0
+
     private var flipFlop = false
     private var lastDuration = 1.0
     private val fireworkTimer = Timer()
 
     init {
         setDefaultAutomationConfig {
             applyEdits {
-                hideAllGroupsExcept(inventoryConfig)
+                hideAllGroupsExcept(inventoryConfig, rotationConfig)
             }
         }
 
@@ -97,14 +120,21 @@ object ElytraFly : Module(
             }
         }
 
-        listen<TickEvent.Post> {
-            if (glidePause > 0) glidePause--
+        onEnable {
+            startPos = player.pos
         }
 
-        listen<PacketEvent.Receive.Post> { event ->
+        onDisable {
+            passingToPos = null
+            if (passObstacles) BaritoneManager.cancel()
+        }
+
+        listen<PacketEvent.Receive.Pre> { event ->
             if (event.packet !is PlayerPositionLookS2CPacket) return@listen
             if (mode == FlyMode.Bounce && player.isGliding) {
-                glidePause = flagPause
+                val snappedDir = getSnappedDir()
+                val closestLinePoint = player.pos.findClosestPointOnLine(snappedDir)
+                pathToValidPoint(closestLinePoint, snappedDir, true)
             }
         }
 
@@ -161,11 +191,37 @@ object ElytraFly : Module(
     }
 
     private fun SafeContext.findFirework(): ItemStack? {
-        val stack = selectStack(count = 1) { isItem(Items.FIREWORK_ROCKET) }
-        return stack.bestItemMatch(player.hotbarStacks) ?: if (inventory) stack.bestItemMatch(player.hotbarAndInventoryStacks) else null
+        val stack = Items.FIREWORK_ROCKET.select()
+        return stack.bestItemMatch(player.hotbarStacks) ?: if (inventory) stack.bestItemMatch(player.inventoryStacks) else null
     }
 
     private fun SafeContext.onTickBounce() {
+        if (!BaritoneManager.isActive) passingToPos = null
+
+        val playerPos = player.pos
+        if (passObstacles && playerPos.let { Vec3d(it.x, startPos.y, it.z) } dist startPos > 0.1) run obstacleChecks@{
+            val snappedDir = getSnappedDir()
+            val closestLinePoint = playerPos.findClosestPointOnLine(snappedDir)
+            passingToPos?.let { passingTo ->
+                if (passingTo.isObstructed(snappedDir)) {
+                    pathToValidPoint(passingTo, snappedDir)
+                }
+                return
+            }
+            if (playerPos dist closestLinePoint <= acceptableOffsetRange) {
+                if (playerPos.let { Vec3d(it.x, closestLinePoint.y, it.z) }.isObstructed(snappedDir))
+                    pathToValidPoint(closestLinePoint, snappedDir)
+                else return@obstacleChecks
+            } else pathToValidPoint(closestLinePoint, snappedDir, true)
+
+            return
+        }
+
+        if (glidePause > 0) {
+            glidePause--
+            return
+        }
+
         if (autoPitch) rotationRequest { pitch(pitch.toFloat()) }.submit()
 
         if (!player.isGliding) {
@@ -184,6 +240,76 @@ object ElytraFly : Module(
         }
     }
 
+    private fun SafeContext.getSnappedDir(): Vec3d {
+        val travelDiff = player.pos.subtract(startPos).normalize().let { Vec3d(it.x, 0.0, it.z) }
+        return lockYawToStep(travelDiff)
+    }
+
+    context(safeContext: SafeContext)
+    private fun pathToValidPoint(startSearchPos: Vec3d, dir: Vec3d, initialBlockedCheck: Boolean = false) {
+        var skippingFirstCheck = !initialBlockedCheck
+        var searchPos = startSearchPos
+        while (skippingFirstCheck || searchPos.isObstructed(dir)) {
+            searchPos = searchPos.add(dir.multiply(obstacleLookAhead.toDouble()))
+            skippingFirstCheck = false
+        }
+        passTo(searchPos)
+        safeContext.player.stopGliding()
+        glidePause = flagPause
+    }
+
+    private fun passTo(pos: Vec3d) {
+        passingToPos = pos
+        BaritoneManager.setGoalAndPath(GoalGetToBlock(pos.flooredBlockPos))
+    }
+
+    context(safeContext: SafeContext)
+    private fun Vec3d.isObstructed(direction: Vec3d) =
+        if (!isLoaded) false
+        else {
+            flooredBlockPos.down().let { downPos ->
+                !safeContext.blockState(downPos).isSolidBlock(safeContext.world, downPos)
+            } ||
+                    rayCastObstructed(direction) ||
+                    add(0.0, 1.0, 0.0).rayCastObstructed(direction) ||
+                    add(0.0, 2.0, 0.0).rayCastObstructed(direction)
+        }
+
+    context(safeContext: SafeContext)
+    private fun Vec3d.rayCastObstructed(direction: Vec3d) =
+        safeContext.rayCast(
+            this,
+            direction,
+            obstacleLookAhead.toDouble(),
+            InteractionMask.Block
+        )?.blockResult != null
+
+    private fun Vec3d.findClosestPointOnLine(snappedDirection: Vec3d): Vec3d {
+        val startToCurrent = subtract(startPos)
+        val t = startToCurrent.dotProduct(snappedDirection) / snappedDirection.dotProduct(snappedDirection)
+        return startPos.add(snappedDirection.multiply(t))
+    }
+
+    fun lockYawToStep(vector: Vec3d): Vec3d {
+        val yaw = atan2(vector.z, vector.x)
+        val yawDegrees = toDegrees(yaw)
+
+        val normalizedYaw = (yawDegrees % 360.0 + 360.0) % 360.0
+
+        val steps = normalizedYaw / directionStep
+        val roundedSteps = steps.roundToInt()
+        val lockedYawDegrees = roundedSteps * directionStep
+
+        val normalizedLockedYawDegrees = (lockedYawDegrees % 360.0 + 360.0) % 360.0
+        val lockedYaw = toRadians(normalizedLockedYawDegrees)
+
+        val horizontalLength = hypot(vector.x, vector.z)
+        val x = cos(lockedYaw) * horizontalLength
+        val z = sin(lockedYaw) * horizontalLength
+
+        return Vec3d(x, vector.y, z)
+    }
+
     @JvmStatic
     fun getModifiedBounceVelocity(original: Vec3d) =
         runSafe {
@@ -204,7 +330,12 @@ object ElytraFly : Module(
             previouslyFlying = original
             return@runSafe original
         }
-        return if (isEnabled && mode == FlyMode.Bounce && previouslyFlying == true && glidePause <= 0) true
+        return if (
+            isEnabled &&
+            mode == FlyMode.Bounce &&
+            previouslyFlying == true &&
+            glidePause <= 0 &&
+            !BaritoneManager.isActive) true
         else {
             previouslyFlying = original
             original
diff --git a/src/main/kotlin/com/lambda/module/modules/player/NoForceRotate.kt b/src/main/kotlin/com/lambda/module/modules/player/NoForceRotate.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2026 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.module.modules.player
+
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+
+object NoForceRotate : Module(
+	name = "NoForceRotate",
+	description = "Prevents the server from forcing your players rotation",
+	tag = ModuleTag.PLAYER
+)
diff --git a/src/main/kotlin/com/lambda/module/modules/player/RotationLock.kt b/src/main/kotlin/com/lambda/module/modules/player/RotationLock.kt
@@ -39,11 +39,11 @@ object RotationLock : Module(
 	}
 
 	@JvmStatic val yawMode by setting("Yaw Mode", Mode.Snap).group(Group.General)
-	private val yawStep by setting("Yaw Step", 45.0, 1.0..180.0, 1.0) { yawMode == Mode.Snap }.group(Group.General)
-	private val customYaw by setting("Custom Yaw", 0.0, -179.0..180.0, 1.0) { yawMode == Mode.Custom }.group(Group.General)
+	private val yawStep by setting("Yaw Step", 45.0, 1.0..180.0, 0.1) { yawMode == Mode.Snap }.group(Group.General)
+	private val customYaw by setting("Custom Yaw", 0.0, -179.0..180.0, 0.1) { yawMode == Mode.Custom }.group(Group.General)
 	@JvmStatic val pitchMode by setting("Pitch Mode", Mode.None).group(Group.General)
-	private val pitchStep by setting("Pitch Step", 45.0, 1.0..90.0, 1.0) { pitchMode == Mode.Snap }.group(Group.General)
-	private val customPitch by setting("Custom Pitch", 0.0, -90.0..90.0, 1.0) { pitchMode == Mode.Custom }.group(Group.General)
+	private val pitchStep by setting("Pitch Step", 45.0, 1.0..90.0, 0.1) { pitchMode == Mode.Snap }.group(Group.General)
+	private val customPitch by setting("Custom Pitch", 0.0, -90.0..90.0, 0.1) { pitchMode == Mode.Custom }.group(Group.General)
 
 	override val rotationConfig = RotationSettings(this, Group.Rotation).apply {
 		applyEdits {
diff --git a/src/main/kotlin/com/lambda/util/BlockUtils.kt b/src/main/kotlin/com/lambda/util/BlockUtils.kt
@@ -20,6 +20,7 @@ package com.lambda.util
 import com.lambda.context.SafeContext
 import com.lambda.util.EnchantmentUtils.getEnchantment
 import com.lambda.util.player.gamemode
+import com.lambda.util.world.WorldUtils.isLoaded
 import net.minecraft.block.AbstractCauldronBlock
 import net.minecraft.block.AbstractFurnaceBlock
 import net.minecraft.block.AbstractSignBlock
@@ -358,4 +359,7 @@ object BlockUtils {
     fun BlockPos.vecOf(direction: Direction): Vec3d = toCenterPos().add(Vec3d.of(direction.vector).multiply(0.5))
     fun BlockPos.offset(eightWayDirection: EightWayDirection, amount: Int): BlockPos =
         add(eightWayDirection.offsetX * amount, 0, eightWayDirection.offsetZ * amount)
+    context(safeContext: SafeContext)
+    val BlockPos.isLoaded get() = safeContext.isLoaded(this)
+
 }
diff --git a/src/main/kotlin/com/lambda/util/math/Vectors.kt b/src/main/kotlin/com/lambda/util/math/Vectors.kt
@@ -17,6 +17,8 @@
 
 package com.lambda.util.math
 
+import com.lambda.context.SafeContext
+import com.lambda.util.BlockUtils.isLoaded
 import com.lambda.util.math.MathUtils.floorToInt
 import com.lambda.util.math.MathUtils.sq
 import net.minecraft.entity.Entity
@@ -200,6 +202,9 @@ infix fun Entity.distSq(other: Vec3d): Double = pos distSq other
 infix fun Entity.distSq(other: Vec3i): Int = blockPos distSq other
 infix fun Entity.distSq(other: Entity): Double = squaredDistanceTo(other)
 
+context(safeContext: SafeContext)
+val Vec3d.isLoaded get() = flooredBlockPos.isLoaded
+
 val UP = Vec3d(0.0, 1.0, 0.0)
 val DOWN = Vec3d(0.0, -1.0, 0.0)
 val CENTER = Vec3d(0.5, 0.5, 0.5)
