The previous shortcut completed an Ascend on any non-FinalStop exit as
soon as the bot's center entered the target column. This made the next
segment start with the bot offset along the prior heading (e.g. +0.45 m
past target column center), which compounded with sprint-jump distance
on the next segment.
Live regression on (237.5, 97, 172.5) -> (252.5, 138, 220.5):
Ascend (258.5,127,222.5)->(257.5,128,223.5) PrepareJump completed at
(257.78,128.00,223.95). Followed by Parkour (257.5,128,223.5)->
(256.5,128,225.5), the sprint-jump launched from progress=+0.38 and
covered ~3.6 m, overshooting the 2.236 m landing target by ~1.7 m. Bot
fell at (255.30,123.94,226.27) and triggered repeated replans until the
5-replan budget was exhausted.
Restrict the shortcut to ExitTransition == Turn, the original target
case where the AscendTemplate yaw and GroundedSegmentController's
exit-heading yaw disagree and oscillate the bot off the landing block.
For PrepareJump/ContinueStraight/LandingRecovery, the GSC handoff is
correct because the next segment shares the segment heading.
Verified zero replans on:
- (237.5,97,172.5) -> (252.5,138,220.5) (79 segments)
- (252.5,138,220.5) -> (237.5,97,172.5) (39 segments)
- (237.5,97,172.5) -> (244.5,122,188.5) (41 segments)
- (244.5,122,188.5) -> (237.5,97,172.5) (25 segments)
Pathing test suite: 23 failures (matches baseline, no new regressions).
Made-with: Cursor
Two coupled fixes for live 258<->237 / 237<->244 routes that previously
hit 5 replans and gave up on Ascend exit=Turn segments.
DescendTemplate: when biasTowardExitInAir is false on a multi-block
diagonal descend, the per-tick targetYaw rotates as the bot drifts past
the landing column mid-fall (e.g. dx=-1 dz=-1 drop yaw cycles 135 -> 90
-> 0 -> 315 over six air ticks). With Forward held, that rotating yaw
pushes air-control momentum perpendicular to the planned trajectory,
sliding the bot ~0.5 m off the landing onto an adjacent block one tier
below. Lock airborne yaw to the segment's start->end heading for those
descends so air drift stays aligned with the diagonal.
AscendTemplate: add a post-landing completion shortcut for non-FinalStop
exits. Once the jump arc puts the bot back on ground at the target's
elevation with its center inside the target column, hand off to the
next template (which snaps yaw on its first tick). Holding the segment
runs both AscendTemplate's top-level yaw smoothing toward a moving
targetYaw AND GroundedSegmentController's segment/exit-heading rotation
each tick. The competing yaw targets oscillate the bot ~80 ticks until
it walks off the 1-block landing's edge and the segment fails. Mirrors
the existing PrepareJump completion gate. FinalStop is excluded so the
last segment still uses IsSettledAtEnd to detect a true stop.
Live verification on 1.21.11 (round-trip 244<->237 plus the originally
failing 237->244 route): four navigations, 0 replans, all 25/41/24/41
segments completed.
Made-with: Cursor
Fix a cluster of execution-layer issues that caused replans and void
falls when traversing narrow ledges and multi-block descents between
(251.5,141,210.5) and (252.5,138,220.5):
- WalkTemplate / GroundedSegmentController: suppress the pre-rotation
bias toward the next segment's exit heading on stable-footing Turn
exits where the next segment is not a jump. The next template
snaps yaw on its first tick anyway, and pre-rotating mid-stride on
a 1-block walkway pushes sprint drift perpendicular to the path and
walks the bot off the edge. Turn exits into a jump still get the
bias so the takeoff direction stays aligned.
- GroundedSegmentController.ShouldComplete: relax the headingReady
gate for Turn exits with stable footing so the segment can complete
once yaw is aligned with either the current or the next segment
heading (within 25/15 deg). Without this the removed bias would
leave the bot stuck at the end of a walkway waiting for a rotation
that never happens.
- DescendTemplate: restrict the airborne exit-heading bias so it only
kicks in when the footprint is inside the landing block, or on
single-step drops where the fall is too short for lateral drift to
miss the landing column. On 2+ block drops the bot now keeps yaw
pointed at the landing center for the whole fall.
- DescendTemplate: add a multi-block overshoot guard on PrepareJump
exits. Once airborne and past the landing end-plane on a 2+ Y
drop, release forward/sprint and press back briefly so air drag
pulls the bot back into the 1x1 landing column instead of sailing
one block past it into the neighbouring void.
Live round-trip between the two goal coordinates now completes with
zero replans in three consecutive runs in each direction. Full unit
test suite is unchanged from the pre-existing baseline (22 failing
tests, all orthogonal to this change).
Made-with: Cursor
Move PathSegmentManager's Replan to Task.Run so the main tick only reads
results and swaps executors, and introduce a _nextExecutor pre-planning
slot so upcoming segments can prepare while the current one finishes.
Relax per-tick yaw/pitch rate limiting: allow instantaneous snapping
before jump ticks (Baritone does this and servers do not kick for it).
Align jump-template success/failure contracts with Baritone:
- Success key shifts from "speed squared" to "feet-on-target block".
- Failure window widened to the ~200 tick range.
- AscendTemplate gets a headBonkClear + edge/side proximity
precondition so launches only happen from a safe takeoff.
Expose an initialMomentumTicks option on TemplateSimulationRunner so
follow-up sidewall scenarios can warm up physics before a template
starts.
Made-with: Cursor
Theory simulator:
- Add 2D side-wall jump physics with yaw sweep for worst-case margin
- Generate sidewall theory cases (flat/ascend/descend, wall_offset 0/1)
- Add momentum-capabilities.json with band compression and max_reach
- Extend models, capabilities, canonical, and renderers for sidewall
Full-coverage parkour test suite (tools/test-parkour.py):
- Derive test matrix from momentum-capabilities.json
- Build linear/neo/ceiling courses via RCON with 7-block clear margin
- Use /goto for pathfinding, parse A* and PathMgr log output
- Stop-at-first-failure per (family, subfamily, dy, ceil, wo) group
- Hierarchical --filter (e.g. linear/flat, ceiling/headhitter/ceil2.5)
- Exclude sidewall from default matrix (identical max_reach to linear)
Pathing execution fixes:
- Align parkour contracts and timing budgets with live test results
- Fix jump-entry yaw snapping for grounded handoffs
- Template helper and sprint jump template refinements
Made-with: Cursor
- Add MoveDiagonalAscend and MoveDiagonalDescend for "corner" moves:
step diagonally around a wall edge while ascending/descending 1 block.
Requires at least one intermediate cardinal direction to be passable.
- Fix pitch calculation: look toward target's eye level (same height
delta as feet delta) instead of subtracting eye height, which caused
the player to stare at the ground during flat walks.
- Add Yaw/Pitch smoothing via SmoothYaw/SmoothPitch in TemplateHelper.
Max 35 deg/tick for yaw, 25 deg/tick for pitch. Prevents instant
camera snaps between path segments while still being responsive
enough for sprint-jumps and tight maneuvers.
- Apply smoothing to all five action templates (Walk, Ascend, Descend,
Climb, SprintJump).
Made-with: Cursor
- WalkTemplate: remove OnClimbable jump/sprint logic that caused the
player to jump when walking past vine blocks during flat traversal
- TemplateHelper: add CalculatePitch() for computing the look angle
toward a 3D target relative to eye height
- All templates (Walk, Ascend, Descend, Climb, SprintJump): set
physics.Pitch each tick so the player visually looks toward the
current path target direction
- McClient: sync playerPitch and set _yaw/_pitch after pathfinding
ticks so rotation is included in position update packets sent to
the server
Made-with: Cursor
Templates now set Forward/Sprint input before checking completion
conditions. This prevents a 1-tick input gap during template transitions
that caused the player to lose sprint speed, making parkour jumps fail
due to insufficient horizontal velocity.
Made-with: Cursor
Phase 2.2: MoveParkour for sprint-jump across 1-2 block gaps (distance 2-3)
and ascending parkour (distance 2, +1Y). Registered in BuildDefaultMoves
with CalculationContext.AllowParkour gating.
Phase 3.1-3.2: Template execution engine replacing the waypoint queue system.
- IActionTemplate interface with per-tick state machine pattern
- Templates: Walk, Ascend, Descend, Climb, Fall, SprintJump
- ActionTemplateFactory maps MoveType to the correct template
- PathExecutor drives sequential template execution with logging
- PathSegmentManager handles replanning on failure (up to 5 retries)
- McClient integration: MoveToAStar now creates PathSegmentManager,
UpdatePathfindingInput delegates to it, CancelMovement/ClientIsMoving
updated for both old and new systems.
Tested on 1.21.11: straight walk, zigzag maze, stair ascent,
1-gap and 2-gap sprint jumps all pass.
Made-with: Cursor
