Updated AutoFly & AutoEat

Author: cev-api

src/main/java/net/wurstclient/hacks/AutoEatHack.java

@@ -255,11 +255,13 @@ private boolean shouldEat()
 		if(!MC.player.canEat(false))
 			return false;
 
+		boolean autoFlyActive = WURST.getHax().autoFlyHack.isEnabled();
+		
 		if(!eatWhileWalking.isChecked()
-			&& (MC.player.zza != 0 || MC.player.xxa != 0))
+			&& !autoFlyActive && (MC.player.zza != 0 || MC.player.xxa != 0))
 			return false;
 
-		if(isClickable(MC.hitResult))
+		if(!autoFlyActive && isClickable(MC.hitResult))
 			return false;
 
 		return true;

src/main/java/net/wurstclient/hacks/AutoFlyHack.java

@@ -404,6 +404,7 @@ public String toString()
 		new SliderSetting("Chunk trail: Single-wall nudge (blocks/step)", 12, 4,
 			32, 1, SliderSetting.ValueDisplay.INTEGER);
 	private boolean flightOverridesApplied;
+	private double chunkTrailSpeedScale = 1.0;
 	private double lastYForProgress = Double.NaN;
 	private long lastVerticalProgressMs;
 	private boolean verticalAssistActive;
@@ -738,6 +739,9 @@ public void onUpdate()
 		if(checkDisableOnDamage())
 			return;
 
+		if(handleAutoEatPause())
+			return;
+		
 		if(allowManualAdjust.isChecked() && isManualInputActive())
 		{
 			beginManualAdjust(MC.player.position());
@@ -2107,8 +2111,10 @@ private void applyFlightSettings()
 	private void applyFlightSpeed()
 	{
 		var flight = WURST.getHax().flightHack;
+		double scale = routeType.getSelected() == RouteType.CHUNKS
+			? chunkTrailSpeedScale : 1.0;
 		double desired = Math.min(flight.horizontalSpeed.getMaximum(),
-			flightSpeed.getValue());
+			flightSpeed.getValue() * MathUtils.clamp(scale, 0.2, 1.0));
 		flight.horizontalSpeed.setValue(desired);
 	}
 
@@ -2386,6 +2392,7 @@ private void applyChunkCorridorAssist()
 	{
 		if(MC.player == null || MC.level == null)
 			return;
+		chunkTrailSpeedScale = 1.0;
 
 		var chunks = WURST.getHax().newerNewChunksHack;
 		var oldTrail = chunks.getOldChunksLiveView();
@@ -2418,6 +2425,7 @@ private void applyChunkCorridorAssist()
 		}
 		if(!playerOnUsableGreen && nearbySafe != null)
 		{
+			chunkTrailSpeedScale = 0.35;
 			ChunkPos recoveryTargetChunk = nearbySafe;
 			if(chunkEdgeRecoveryAnchor != null && chunkEdgeRecoveryTicks > 0
 				&& isOldTrailNotNew(oldTrail, newSet, chunkEdgeRecoveryAnchor))
@@ -2557,15 +2565,16 @@ && isTargetStillAhead(chunkCorridorTargetPos, playerForwardProgress)
 				}
 				if(recoveryTarget != null)
 				{
+					chunkTrailSpeedScale = 0.35;
 					chunkNoTargetTicks++;
 					chunkTrailEndConfirmStrikes = 0;
 					chunkCorridorTargetPos = recoveryTarget;
 					return;
 				}
 			}
 
-			// Keep moving forward even without detected borders. Use current
-			// forward axis (or look direction) to set a provisional target.
+			// If the green corridor has not caught up yet, slow down hard and
+			// favor nearby known old chunks instead of charging into red.
 			chunkNoTargetTicks++;
 			if(chunkCorridorTargetPos != null && isTargetStillAhead(
 				chunkCorridorTargetPos, playerForwardProgress))
@@ -2580,34 +2589,45 @@ && isTargetStillAhead(chunkCorridorTargetPos, playerForwardProgress)
 				chunkCorridorTargetPos = null;
 				return;
 			}
-			double lead = CHUNK_NO_TARGET_FORWARD_LEAD_BLOCKS;
-			// After grace, extend the lead to keep cruising smoothly.
-			if(chunkNoTargetTicks > CHUNK_NO_TARGET_GRACE_TICKS)
-				lead = Math.max(lead, 32.0);
-			Vec3 provisional = playerPos.add(axis.normalize().scale(lead));
-			
-			// Single/both-wall avoidance: nudge away from red walls and
-			// center between them when both are detected.
 			Vec3 right = new Vec3(-axis.z, 0.0, axis.x);
 			ChunkPos pChunk = ChunkPos.containing(MC.player.blockPosition());
 			int leftDist = distanceToNearestNewWall(newSet, pChunk, right, -1,
 				CHUNK_WALL_SCAN_RADIUS);
 			int rightDist = distanceToNearestNewWall(newSet, pChunk, right, 1,
 				CHUNK_WALL_SCAN_RADIUS);
+			Vec3 looseOldTarget = selectLooseOldTrailTarget(oldTrail, newSet,
+				playerPos, pChunk, axis, right, playerForwardProgress);
+			double lead = Math.min(CHUNK_NO_TARGET_FORWARD_LEAD_BLOCKS, 10.0);
+			chunkTrailSpeedScale =
+				chunkNoTargetTicks > CHUNK_NO_TARGET_GRACE_TICKS ? 0.2 : 0.35;
+			Vec3 provisional = looseOldTarget != null ? looseOldTarget
+				: playerPos.add(axis.normalize().scale(lead));
+			
+			// Single/both-wall avoidance: nudge away from red walls and
+			// center between them when both are detected.
 			double lateral = 0.0;
 			if(leftDist > 0 && rightDist > 0)
 			{
 				double centerOffsetChunks = (rightDist - leftDist) * 0.5;
 				lateral +=
 					Math.max(-24.0, Math.min(24.0, centerOffsetChunks * 16.0));
+				int nearestWall = Math.min(leftDist, rightDist);
+				if(nearestWall <= 2)
+					chunkTrailSpeedScale = Math.min(chunkTrailSpeedScale, 0.35);
 			}else
 			{
 				int guard = Math.max(3, CHUNK_MIN_CORRIDOR_THICKNESS);
 				double nudge = getSingleWallNudgeStrength();
 				if(leftDist > 0 && leftDist <= guard)
+				{
 					lateral += (guard + 1 - leftDist) * nudge; // push right
+					chunkTrailSpeedScale = Math.min(chunkTrailSpeedScale, 0.35);
+				}
 				if(rightDist > 0 && rightDist <= guard)
+				{
 					lateral -= (guard + 1 - rightDist) * nudge; // push left
+					chunkTrailSpeedScale = Math.min(chunkTrailSpeedScale, 0.35);
+				}
 			}
 			if(Math.abs(lateral) > 0.01)
 				provisional = provisional.add(right.normalize().scale(lateral));
@@ -2676,6 +2696,7 @@ && isTargetStillAhead(chunkCorridorTargetPos, playerForwardProgress)
 	public void clearChunkCorridorAssist()
 	{
 		chunkAssistActive = false;
+		chunkTrailSpeedScale = 1.0;
 		chunkCorridorAnchor = null;
 		chunkCorridorOrigin = null;
 		chunkCorridorHeading = null;
@@ -3007,6 +3028,84 @@ private Vec3 selectChunkCorridorTargetPos(java.util.Set<ChunkPos> oldTrail,
 		return null;
 	}
 
+	private Vec3 selectLooseOldTrailTarget(java.util.Set<ChunkPos> oldTrail,
+		java.util.Set<ChunkPos> newChunks, Vec3 playerPos, ChunkPos playerChunk,
+		Vec3 forward, Vec3 right, double playerForwardProgress)
+	{
+		if(oldTrail == null || oldTrail.isEmpty() || playerPos == null
+			|| playerChunk == null || forward == null || right == null)
+			return null;
+		
+		Vec3 flatForward = new Vec3(forward.x, 0.0, forward.z);
+		if(flatForward.lengthSqr() < 1.0E-6)
+			return null;
+		flatForward = flatForward.normalize();
+		
+		ChunkPos best = null;
+		double bestScore = Double.NEGATIVE_INFINITY;
+		int forwardLimit = Math.max(2, getAheadScanChunks());
+		int sideLimit = Math.max(1, getSideScanHalfWidth() + 2);
+		for(int f = 0; f <= forwardLimit; f++)
+		{
+			ChunkPos front = stepChunk(playerChunk, flatForward, f);
+			for(int w = -sideLimit; w <= sideLimit; w++)
+			{
+				ChunkPos candidate = stepChunk(front, right, w);
+				if(!isOldTrailNotNew(oldTrail, newChunks, candidate))
+					continue;
+				
+				Vec3 center = Vec3.atCenterOf(chunkCenter(candidate));
+				Vec3 delta = center.subtract(playerPos);
+				Vec3 dir = new Vec3(delta.x, 0.0, delta.z);
+				if(dir.lengthSqr() < 1.0E-6)
+					continue;
+				dir = dir.normalize();
+				
+				double along = dir.dot(flatForward);
+				if(along < CHUNK_MIN_FORWARD_DOT)
+					continue;
+				
+				double targetProgress =
+					chunkCorridorOrigin != null ? projectAlongHeading(center,
+						chunkCorridorOrigin, flatForward) : Double.NaN;
+				if(!Double.isNaN(playerForwardProgress)
+					&& !Double.isNaN(targetProgress)
+					&& targetProgress < playerForwardProgress
+						- CHUNK_BACKTRACK_BLOCK_TOLERANCE)
+					continue;
+				
+				double dist = Math.max(1.0, Math.hypot(delta.x, delta.z));
+				double lateral = Math.abs(dir.dot(right));
+				int leftWallDist = distanceToNearestNewWall(newChunks,
+					candidate, right, -1, CHUNK_WALL_SCAN_RADIUS);
+				int rightWallDist = distanceToNearestNewWall(newChunks,
+					candidate, right, 1, CHUNK_WALL_SCAN_RADIUS);
+				double wallScore = 0.0;
+				if(leftWallDist > 0 && rightWallDist > 0)
+					wallScore += Math.min(leftWallDist, rightWallDist) * 1.5
+						- Math.abs(leftWallDist - rightWallDist) * 2.0;
+				else if(leftWallDist > 0 || rightWallDist > 0)
+					wallScore += 1.0;
+				
+				double score = along * 18.0 - lateral * 6.0 - dist * 0.12
+					+ wallScore - getRecentCorridorPenalty(candidate);
+				if(!Double.isNaN(playerForwardProgress)
+					&& !Double.isNaN(targetProgress))
+					score +=
+						Math.min(32.0, targetProgress - playerForwardProgress)
+							* 0.25;
+				
+				if(score > bestScore)
+				{
+					bestScore = score;
+					best = candidate;
+				}
+			}
+		}
+		
+		return best != null ? Vec3.atCenterOf(chunkCenter(best)) : null;
+	}
+	
 	private static int distanceToNearestNewWall(
 		java.util.Set<ChunkPos> newChunks, ChunkPos from, Vec3 right,
 		int directionSign, int maxSteps)
@@ -3857,6 +3956,31 @@ private void beginManualAdjust(Vec3 playerPos)
 		PathProcessor.releaseControls();
 	}
 
+	private boolean handleAutoEatPause()
+	{
+		if(!WURST.getHax().autoEatHack.isEating())
+			return false;
+		
+		long now = System.currentTimeMillis();
+		ensureFlightEnabled();
+		applyFlightSpeed();
+		PathProcessor.releaseControls();
+		resetAutoKeyFlags();
+		clearMovementKeys();
+		clearPathingState();
+		manualAdjustHold = false;
+		manualAdjustStartMs = 0L;
+		manualAdjustStartPos = null;
+		lastProgressMs = now;
+		lastProgressDist = Double.NaN;
+		lastMovePos = MC.player.position();
+		lastMoveMs = now;
+		lastHorizPos = lastMovePos;
+		lastHorizMoveMs = now;
+		lastAutoControlMs = 0L;
+		return true;
+	}
+	
 	private void handleManualAdjust()
 	{
 		if(MC.player == null)
@@ -3983,6 +4107,41 @@ else if(key == MC.options.keyShift)
 			autoKeyShiftDown = down;
 	}
 
+	public boolean isProvidingAutoFlyInput()
+	{
+		return isEnabled() && anyAutoKeyDown();
+	}
+	
+	public boolean isAutoKeyUpDown()
+	{
+		return autoKeyUpDown;
+	}
+	
+	public boolean isAutoKeyDownDown()
+	{
+		return autoKeyDownDown;
+	}
+	
+	public boolean isAutoKeyLeftDown()
+	{
+		return autoKeyLeftDown;
+	}
+	
+	public boolean isAutoKeyRightDown()
+	{
+		return autoKeyRightDown;
+	}
+	
+	public boolean isAutoKeyJumpDown()
+	{
+		return autoKeyJumpDown;
+	}
+	
+	public boolean isAutoKeyShiftDown()
+	{
+		return autoKeyShiftDown;
+	}
+	
 	private void resetAutoKeyFlags()
 	{
 		autoKeyUpDown = false;

src/main/java/net/wurstclient/hacks/FlightHack.java

@@ -12,6 +12,7 @@
 import net.minecraft.tags.FluidTags;
 import net.minecraft.util.Mth;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.Vec2;
 import net.minecraft.world.phys.Vec3;
 import net.wurstclient.Category;
 import net.wurstclient.SearchTags;
@@ -227,19 +228,24 @@ public void onUpdate()
 
 		double vSpeed = getActualVerticalSpeed();
 
-		if(MC.options.keyJump.isDown())
+		AutoFlyHack autoFly = WURST.getHax().autoFlyHack;
+		boolean autoJump = autoFly.isAutoKeyJumpDown();
+		boolean autoShift = autoFly.isAutoKeyShiftDown();
+		if(MC.options.keyJump.isDown() || autoJump)
 			player.addDeltaMovement(new Vec3(0, vSpeed, 0));
 
 		boolean shiftActuallyDown =
 			IKeyMapping.get(MC.options.keyShift).isActuallyDown();
 		boolean allowShiftInThisContext =
 			!ignoreShiftInGuis.isChecked() || MC.screen == null;
-		if(shiftActuallyDown && allowShiftInThisContext)
+		if((shiftActuallyDown && allowShiftInThisContext) || autoShift)
 		{
 			MC.options.keyShift.setDown(false);
 			player.addDeltaMovement(new Vec3(0, -vSpeed, 0));
 		}
 
+		applyAutoFlyHorizontalVelocity(player, autoFly);
+		
 		if(isAntiKickEnabled())
 			doAntiKick();
 
@@ -255,6 +261,47 @@ public void onUpdate()
 		}
 	}
 
+	private void applyAutoFlyHorizontalVelocity(LocalPlayer player,
+		AutoFlyHack autoFly)
+	{
+		if(!autoFly.isProvidingAutoFlyInput())
+			return;
+		
+		Vec2 moveVector =
+			player.input != null ? player.input.getMoveVector() : Vec2.ZERO;
+		if(moveVector.lengthSquared() > 1.0E-5F)
+			return;
+		
+		double forwardImpulse = 0.0;
+		double sideImpulse = 0.0;
+		if(autoFly.isAutoKeyUpDown())
+			forwardImpulse += 1.0;
+		if(autoFly.isAutoKeyDownDown())
+			forwardImpulse -= 1.0;
+		if(autoFly.isAutoKeyLeftDown())
+			sideImpulse += 1.0;
+		if(autoFly.isAutoKeyRightDown())
+			sideImpulse -= 1.0;
+		
+		if(forwardImpulse == 0.0 && sideImpulse == 0.0)
+			return;
+		
+		Vec3 forward =
+			Vec3.directionFromRotation(0.0F, player.getYRot()).normalize();
+		forward = new Vec3(forward.x, 0.0, forward.z);
+		if(forward.lengthSqr() < 1.0E-6)
+			return;
+		forward = forward.normalize();
+		Vec3 right = new Vec3(-forward.z, 0.0, forward.x);
+		Vec3 movement =
+			forward.scale(forwardImpulse).add(right.scale(sideImpulse));
+		if(movement.lengthSqr() < 1.0E-6)
+			return;
+		
+		double speed = horizontalSpeed.getValue();
+		player.addDeltaMovement(movement.normalize().scale(speed));
+	}
+	
 	private void syncNoSlowdownVineIgnore()
 	{
 		NoSlowdownHack noSlowdown = WURST.getHax().noSlowdownHack;