fix(fps): a backflip's takeoff rises as at 60 fps above a 60 cap (HOS_FPS_TAKEOFF) #2071

Merged
HumanBean merged 1 commit from GummiNaomi/Longshot:fix/downhill-contact-fps into main 2026-11-21 17:24:40 +00:00
Member

Summary

Above a Frame rate cap of 60, a backflip down a slope took off twice and carried Link about 24 % farther (2.77-2.86 m against
2.25 m in Hyrule Field). f_80b97d10 computes a jump's takeoff speed and f_804f5030 hands Havok Link's body that speed on the
takeoff's update (the world's set-velocity call). On a backflip the next update hands no vertical speed, so the body hops by one
step of the takeoff speed: 6.4 cm at 60 fps, 4.2 cm at 94. From the lower hop he met the slope at 0.1 s, the controller landed
and the backflip took off again. Now f_80b97d10 hands the speed to the host, and right before the set-velocity call a body
handed the takeoff speed in the takeoff's own update is watched: when the next update asks it for no vertical speed, that
update gets the rest of a 60 fps takeoff step's rise, above a 60 cap on a frame shorter than a 60 fps one. A body the game
keeps raising (a side hop) already rises as at 60 under the variable step and is left as it is. A cap of 60 is unchanged.

Read first: oot_takeoff_match and oot_takeoff_rest_speed in host/oot_high_fps.h (the rule and why), patch_jump_speed
and patch_takeoff_velocity in nx2/oot_patches.py, then tests/test_jump_takeoff_step.py.

See #1740 (the same function's driven bodies; left as it is).

Testing

Tested: Windows 11 Pro 26200, RTX 4070 SUPER, Ryzen 9 9950X3D with SMT off: a build of main @ e6196f0f with this change,
the movement probe (control bridge, kokiri-start save) at cap 60 and Uncapped (109-110 fps), a verify run and two launches
with the change, two with HOS_FPS_TAKEOFF=0: Hyrule Field (run, roll, two side hops, backflip down a slope, a run down it),
Kakariko's steps up and down, the Market; 0 errors in the logs. The commit was then moved onto main @ 9dd41326 with no conflict
(the same patch; main's 8 newer commits do not touch these functions, and #1905 leaves the lifted functions' C text as it was):
the slope measurements are from the e6196f0f build; this head was built and played later, in the move probe below, and
the checks below ran on it.

Adult Link and the other moves (21 Nov, a move probe with the same setup, cap 60 and Uncapped 99-120 fps in each launch, two
launches a build): this head, built on main @ 9dd41326, against main @ 66dc0a51. The adult backflip has the child's bug on main
(its first hop above 60 is 2 cm against 5 cm at 60, and it lands 4 % short, 2.25 / 2.27 m against 2.36 m, with one takeoff
from this spot); on this head the hop above 60 is 5-6 cm, as at 60. The other moves the repository's saves reach move as at
60 on both builds: the camera (right stick 108.6-108.8 deg/s, recentred on Z in 0.24-0.26 s), the Z sidestep and backpedal
(within 1 %), Death Mountain Trail up and down (within 0.5 %), running off the Goron City ledge (a plain fall, 4.46-4.51 m
along at landing at both caps), the adult run.

Checks (Windows, clang, no gcc here), each also run on main @ 9dd41326: tests/run_all.py --changed picks 73 checks: 32
pass, 14 fail, 27 skip. The 22 skipped for gcc or g++ alone ran by hand with --cc clang / --cxx clang++ (-lm dropped: no m.lib with the
Windows runtime): 19 pass, tests/test_jump_takeoff_step.py and test_drive_target among them, test_gpu_clock skips
itself, test_song_note_cue and test_text_size do not compile with clang, as on main. The 14 fail the same way on main:
test_bc_small_scratch, test_crash_dialog, test_dev_ab, test_dev_packs, test_frame_overlap, test_frame_whole,
test_high_fps_fixes, test_lift_cache, test_linux_pressure, test_oot_cloth_60, test_oot_cloth_time,
test_quick_pipelines, test_texture_ahead, test_water_substeps. On main's lift tests/test_jump_takeoff_step.py's
94 fps case fails (4.2 cm against 6.6). mise run test: not run whole (no mise here).

Still to test:

  • Linux desktop above a 60 cap: this PR's build against main in Hyrule Field, backflips down a slope, side hops, a jump
    attack and running off a ledge, then at a 60 cap, expecting no crash or hang and frame times as main's (Test Farm:
    @Beanstalk linux, asked in a comment; its planner can't time the jumps themselves, run game-free tests or measure where
    Link lands, and offers the movement with a backflip, uncapped and at 60, with frame times measured after: that plan
    waits for a BigBean's @Beanstalk test it anyway)
  • Linux (gcc): tests/test_jump_takeoff_step.py, expecting PASS (by hand; CI's Python checks run only when started by
    hand)
  • Any PC above a 60 cap: a jump attack and a jump on the horse (the repository's saves have no sword or horse), expecting
    them as at 60 (by hand)

Measurements

Verdict: one takeoff and within 5 % of 60's distance above 60 fps (was two and +20-24 %); side hops as before; 60 unchanged.

Setup: Windows 11 Pro 26200, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off; one build of main @ e6196f0f with
this change (the same patch as this head), headless with the control bridge and the movement probe (Link's position streamed
every frame), kokiri-start save; the Before column is that build with HOS_FPS_TAKEOFF=0 (the game's own speed, as main);
cap 60 and Uncapped (108.8-109.7 fps) in each launch, two launches a side, the sides interleaved. Distances from Link's
position at the takeoff; the paths are his position every 50 ms against the same launch's cap 60 block, the mean.

Before: main @ e6196f0f (HOS_FPS_TAKEOFF=0) After: this PR @ a0e9b5eb (built on e6196f0f)
backflip down the slope, Uncapped ~109 fps: takeoffs, distance from the takeoff, time 2, 2.84 / 2.93 m, 0.42 / 0.43 s 1, 2.37 / 2.42 m, 0.35 / 0.36 s
the same at cap 60 1, 2.35-2.37 m, 0.34 s 1, 2.35-2.37 m, 0.34 s
the second side hop on the slope, Uncapped (60: 0.32-0.35 m) 0.31 / 0.31 m 0.31 / 0.32 m
the adult backflip's first hop (its height in the first 25-50 ms), Uncapped (60: 5 cm) 2 / 2 cm (main @ 66dc0a51) 5-6 / 5 cm (built on 9dd41326)
the Hyrule Field sequence (18 s), Uncapped: path against cap 60, mean 0.14 / 0.17 m 0.06 / 0.10 m
Kakariko steps up and down, the Market, Uncapped: path against cap 60, mean 0.05-0.17 m 0.06-0.15 m

HOS_FPS_TAKEOFF (new, a kill switch) ships on; =0 brings the game's speed back.

Risks

A jump through f_80b97d10 whose next update asks no vertical speed now rises in its first two updates as at 60 above a 60
cap; a jump the game keeps raising is unchanged. f_804f5030 calls the host once a body an update; it returns at once unless a
takeoff is in its 50 ms, and then keeps at most 8 bodies under a lock. Turning it off: HOS_FPS_TAKEOFF=0. After updating:
nothing changes for saves, longshot_options.ini or the caches.

Checklist

Ready for review

  • One topic, on current main; the title is a Conventional Commit.
  • Tested on my own PC, in the game for a change the game runs, as Testing says.
  • mise run test passes (any failure that also fails on main is named). (Not run whole; the changed-file checks as Testing says, each failure also fails on main.)
  • Measured against main, or Measurements says why there is nothing to measure.
  • No game files, build output or hand-edited generated files; third_party/ untouched; nothing GPL-incompatible.

When it applies

  • A fix: a game-free test that fails on main and passes here.
  • A switch added or changed: it ships at the default the measurements chose, with its row in gpu/vk/switches.def.
  • A check under tests/ that reads changed source is updated, not weakened. (None needed a change; Testing says which
    ran.)
  • Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (Windows build only; Linux builds are done by
    someone else.)
  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.

Ready to merge

  • Everything in Still to test has run, its results in Tested.
  • Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers").
  • Approved in review, every comment answered.
  • CI passes on the head; on current main, measured again or a comment says why the numbers still hold.

🤖 Generated with Claude Code

## Summary Above a Frame rate cap of 60, a backflip down a slope took off twice and carried Link about 24 % farther (2.77-2.86 m against 2.25 m in Hyrule Field). `f_80b97d10` computes a jump's takeoff speed and `f_804f5030` hands Havok Link's body that speed on the takeoff's update (the world's set-velocity call). On a backflip the next update hands no vertical speed, so the body hops by one step of the takeoff speed: 6.4 cm at 60 fps, 4.2 cm at 94. From the lower hop he met the slope at 0.1 s, the controller landed and the backflip took off again. Now `f_80b97d10` hands the speed to the host, and right before the set-velocity call a body handed the takeoff speed in the takeoff's own update is watched: when the next update asks it for no vertical speed, that update gets the rest of a 60 fps takeoff step's rise, above a 60 cap on a frame shorter than a 60 fps one. A body the game keeps raising (a side hop) already rises as at 60 under the variable step and is left as it is. A cap of 60 is unchanged. Read first: `oot_takeoff_match` and `oot_takeoff_rest_speed` in `host/oot_high_fps.h` (the rule and why), `patch_jump_speed` and `patch_takeoff_velocity` in `nx2/oot_patches.py`, then `tests/test_jump_takeoff_step.py`. See #1740 (the same function's driven bodies; left as it is). ## Testing **Tested:** Windows 11 Pro 26200, RTX 4070 SUPER, Ryzen 9 9950X3D with SMT off: a build of main @ e6196f0f with this change, the movement probe (control bridge, `kokiri-start` save) at cap 60 and Uncapped (109-110 fps), a verify run and two launches with the change, two with `HOS_FPS_TAKEOFF=0`: Hyrule Field (run, roll, two side hops, backflip down a slope, a run down it), Kakariko's steps up and down, the Market; 0 errors in the logs. The commit was then moved onto main @ 9dd41326 with no conflict (the same patch; main's 8 newer commits do not touch these functions, and #1905 leaves the lifted functions' C text as it was): the slope measurements are from the e6196f0f build; this head was built and played later, in the move probe below, and the checks below ran on it. Adult Link and the other moves (21 Nov, a move probe with the same setup, cap 60 and Uncapped 99-120 fps in each launch, two launches a build): this head, built on main @ 9dd41326, against main @ 66dc0a51. The adult backflip has the child's bug on main (its first hop above 60 is 2 cm against 5 cm at 60, and it lands 4 % short, 2.25 / 2.27 m against 2.36 m, with one takeoff from this spot); on this head the hop above 60 is 5-6 cm, as at 60. The other moves the repository's saves reach move as at 60 on both builds: the camera (right stick 108.6-108.8 deg/s, recentred on Z in 0.24-0.26 s), the Z sidestep and backpedal (within 1 %), Death Mountain Trail up and down (within 0.5 %), running off the Goron City ledge (a plain fall, 4.46-4.51 m along at landing at both caps), the adult run. Checks (Windows, clang, no gcc here), each also run on main @ 9dd41326: `tests/run_all.py --changed` picks 73 checks: 32 pass, 14 fail, 27 skip. The 22 skipped for gcc or g++ alone ran by hand with `--cc clang` / `--cxx clang++` (`-lm` dropped: no `m.lib` with the Windows runtime): 19 pass, `tests/test_jump_takeoff_step.py` and `test_drive_target` among them, `test_gpu_clock` skips itself, `test_song_note_cue` and `test_text_size` do not compile with clang, as on main. The 14 fail the same way on main: `test_bc_small_scratch`, `test_crash_dialog`, `test_dev_ab`, `test_dev_packs`, `test_frame_overlap`, `test_frame_whole`, `test_high_fps_fixes`, `test_lift_cache`, `test_linux_pressure`, `test_oot_cloth_60`, `test_oot_cloth_time`, `test_quick_pipelines`, `test_texture_ahead`, `test_water_substeps`. On main's lift `tests/test_jump_takeoff_step.py`'s 94 fps case fails (4.2 cm against 6.6). `mise run test`: not run whole (no mise here). **Still to test:** - Linux desktop above a 60 cap: this PR's build against main in Hyrule Field, backflips down a slope, side hops, a jump attack and running off a ledge, then at a 60 cap, expecting no crash or hang and frame times as main's (Test Farm: @Beanstalk linux, asked in a comment; its planner can't time the jumps themselves, run game-free tests or measure where Link lands, and offers the movement with a backflip, uncapped and at 60, with frame times measured after: that plan waits for a BigBean's `@Beanstalk test it anyway`) - Linux (gcc): `tests/test_jump_takeoff_step.py`, expecting PASS (by hand; CI's Python checks run only when started by hand) - Any PC above a 60 cap: a jump attack and a jump on the horse (the repository's saves have no sword or horse), expecting them as at 60 (by hand) ## Measurements **Verdict:** one takeoff and within 5 % of 60's distance above 60 fps (was two and +20-24 %); side hops as before; 60 unchanged. Setup: Windows 11 Pro 26200, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off; one build of main @ e6196f0f with this change (the same patch as this head), headless with the control bridge and the movement probe (Link's position streamed every frame), `kokiri-start` save; the Before column is that build with `HOS_FPS_TAKEOFF=0` (the game's own speed, as main); cap 60 and Uncapped (108.8-109.7 fps) in each launch, two launches a side, the sides interleaved. Distances from Link's position at the takeoff; the paths are his position every 50 ms against the same launch's cap 60 block, the mean. | | Before: main @ e6196f0f (`HOS_FPS_TAKEOFF=0`) | After: this PR @ a0e9b5eb (built on e6196f0f) | |---|---|---| | backflip down the slope, Uncapped ~109 fps: takeoffs, distance from the takeoff, time | 2, 2.84 / 2.93 m, 0.42 / 0.43 s | 1, 2.37 / 2.42 m, 0.35 / 0.36 s | | the same at cap 60 | 1, 2.35-2.37 m, 0.34 s | 1, 2.35-2.37 m, 0.34 s | | the second side hop on the slope, Uncapped (60: 0.32-0.35 m) | 0.31 / 0.31 m | 0.31 / 0.32 m | | the adult backflip's first hop (its height in the first 25-50 ms), Uncapped (60: 5 cm) | 2 / 2 cm (main @ 66dc0a51) | 5-6 / 5 cm (built on 9dd41326) | | the Hyrule Field sequence (18 s), Uncapped: path against cap 60, mean | 0.14 / 0.17 m | 0.06 / 0.10 m | | Kakariko steps up and down, the Market, Uncapped: path against cap 60, mean | 0.05-0.17 m | 0.06-0.15 m | `HOS_FPS_TAKEOFF` (new, a kill switch) ships on; `=0` brings the game's speed back. ## Risks A jump through `f_80b97d10` whose next update asks no vertical speed now rises in its first two updates as at 60 above a 60 cap; a jump the game keeps raising is unchanged. `f_804f5030` calls the host once a body an update; it returns at once unless a takeoff is in its 50 ms, and then keeps at most 8 bodies under a lock. Turning it off: `HOS_FPS_TAKEOFF=0`. After updating: nothing changes for saves, `longshot_options.ini` or the caches. ## Checklist ### Ready for review - [x] One topic, on current `main`; the title is a Conventional Commit. - [x] Tested on my own PC, in the game for a change the game runs, as Testing says. - [ ] `mise run test` passes (any failure that also fails on `main` is named). (Not run whole; the changed-file checks as Testing says, each failure also fails on main.) - [x] Measured against `main`, or Measurements says why there is nothing to measure. - [x] No game files, build output or hand-edited generated files; `third_party/` untouched; nothing GPL-incompatible. ### When it applies - [x] A fix: a game-free test that fails on `main` and passes here. - [x] A switch added or changed: it ships at the default the measurements chose, with its row in `gpu/vk/switches.def`. - [x] A check under `tests/` that reads changed source is updated, not weakened. (None needed a change; Testing says which ran.) - [ ] Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (Windows build only; Linux builds are done by someone else.) - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. ### Ready to merge - [ ] Everything in Still to test has run, its results in Tested. - [ ] Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers"). - [ ] Approved in review, every comment answered. - [ ] CI passes on the head; on current `main`, measured again or a comment says why the numbers still hold. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
fix(fps): a backflip's takeoff rises as at 60 fps above a 60 cap (HOS_FPS_TAKEOFF)
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 7s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 12s
CI / Workflow lint (actionlint) (pull_request) Successful in 12s
Third-party parts / As their notes say (pull_request) Successful in 15s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Website build and checks (pull_request) Successful in 4m9s
PR description / Description follows the template (pull_request_target) Failing after 4s
beanstalk/approval can't be tested as asked: see the farm's comment
a0e9b5eb14
Above a Frame rate cap of 60, a backflip down a slope took off twice and carried Link about 24 % farther (2.77-2.86 m against
2.25 m in Hyrule Field). f_80b97d10 computes a jump's takeoff speed and f_804f5030 hands Havok Link's body that speed on the
takeoff's update (the world's set-velocity call). On a backflip the next update hands no vertical speed, so the body hops by one
step of the takeoff speed: 6.4 cm at 60 fps, 4.2 cm at 94. From the lower hop he met the slope at 0.1 s, the controller landed
and the backflip took off again. Now f_80b97d10 hands the speed to the host, and right before the set-velocity call a body
handed the takeoff speed in the takeoff's own update is watched: when the next update asks it for no vertical speed, that
update gets the rest of a 60 fps takeoff step's rise, above a 60 cap on a frame shorter than a 60 fps one. A body the game
keeps raising (a side hop) already rises as at 60 under the variable step and is left as it is. A cap of 60 is unchanged.

Measured in the game (Hyrule Field, Kakariko, the Market; cap 60 and Uncapped ~109 fps, a verify run and two launches with
the change, two with HOS_FPS_TAKEOFF=0): the backflip takes off once, 2.37 / 2.42 / 2.47 m from the takeoff in 0.35-0.36 s
(2.35-2.37 m in 0.34 s at 60; =0: twice, 2.84 / 2.93 m); the second side hop lands 0.30-0.32 m along as at 60 and with =0;
the Hyrule Field sequence's path against cap 60 is 0.06-0.10 m mean (=0: 0.14-0.17); Kakariko's steps and the Market as
before.

- host/oot_high_fps.h: oot_takeoff_match, oot_takeoff_rest_speed (the rule and why)
- host/oot_high_fps.c: hos_oot_jump_speed, hos_oot_takeoff_velocity (at most 8 watched bodies under a lock)
- nx2/oot_patches.py: patch_jump_speed (f_80b97d10), patch_takeoff_velocity (f_804f5030's set-velocity call)
- gpu/vk/switches.def: HOS_FPS_TAKEOFF (a kill switch, on)
- tests/test_jump_takeoff_step.py: two updates a case; fails on main (94 fps: 4.2 cm against 6.6)

Assisted-by: Claude Code
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Author
Member

@Beanstalk Linux, a desktop PC that runs well above 60 fps (not the Steam Deck): this PR against main, two runs a side. In Hyrule Field as a child (HyruleField_Child), with the Frame rate cap off (unlimited), play the jumps that go through the changed takeoff code, each three times with a second's pause between: a backflip down a slope (hold Z-target, then the stick back + A), a side hop each way (Z-target held, the stick left or right + A), a jump attack if the save has a sword (Z-target + A), and running off a ledge. Then the same at a 60 cap. Measure frame times over the jumps.

Fail on a crash or a hang, or frame times (p99) more than 10 % above main's. Upload a picture right after the first backflip lands on each side, not compared with main: above 60, main's backflip takes off a second time and carries Link about 0.5 m farther, so the pictures are expected to differ.

HOS_FPS_TAKEOFF is this PR's new switch (on by default; =0 is the game's own speed); it logs no value line.

@Beanstalk Linux, a desktop PC that runs well above 60 fps (not the Steam Deck): this PR against main, two runs a side. In Hyrule Field as a child (HyruleField_Child), with the Frame rate cap off (unlimited), play the jumps that go through the changed takeoff code, each three times with a second's pause between: a backflip down a slope (hold Z-target, then the stick back + A), a side hop each way (Z-target held, the stick left or right + A), a jump attack if the save has a sword (Z-target + A), and running off a ledge. Then the same at a 60 cap. Measure frame times over the jumps. Fail on a crash or a hang, or frame times (p99) more than 10 % above main's. Upload a picture right after the first backflip lands on each side, not compared with main: above 60, main's backflip takes off a second time and carries Link about 0.5 m farther, so the pictures are expected to differ. `HOS_FPS_TAKEOFF` is this PR's new switch (on by default; `=0` is the game's own speed); it logs no value line.
Member

Beanstalk test farm · ⛔ can't be tested as asked

Commit a0e9b5e · approved by GummiNaomi (untrusted) · dashboard

Not run: the farm can't test this as asked, so nothing is built or run:

The request requires p99 frame times while scripted jumps are being performed, but measurement steps and input steps run sequentially, so the farm cannot measure that interval as requested. The alternative measures a stationary segment after an attempted movement instead, and cannot verify the requested simultaneous targeting, stick and button inputs or landing distance.

⚠️ Note: The discrete-GPU tag is only a desktop proxy; it does not guarantee a non-Steam-Deck PC or performance well above 60 fps.
⚠️ Note: The alternative does not perform all requested jumps or verify that its picture follows a backflip landing; the save does not establish sword ownership.
⚠️ Note: The farm cannot run the separate GCC unit test or measure Link's landing position.

What it could test instead: The alternative plan builds main and the PR on a Linux discrete-GPU PC, then exercises movement in child Hyrule Field at uncapped and 60 fps, with two runs per side. It records an unpaired picture after an attempted backflip and compares p99 frame time in a subsequent stationary segment; a crash, hang, or p99 increase over 10% fails. The lift builds are also timed. This alternative cannot establish the requested jump-frame performance or landing behavior.

A member of BigBeans can comment @Beanstalk <new words> to ask for something else, or @Beanstalk test it anyway to run the plan regardless.

<!-- beanstalk:sticky --> ### Beanstalk test farm · ⛔ can't be tested as asked Commit `a0e9b5e` · approved by GummiNaomi (untrusted) · [dashboard](https://beanstalk.magicbean.dev/prs/2071) **Not run: the farm can't test this as asked**, so nothing is built or run: > The request requires p99 frame times while scripted jumps are being performed, but measurement steps and input steps run sequentially, so the farm cannot measure that interval as requested. The alternative measures a stationary segment after an attempted movement instead, and cannot verify the requested simultaneous targeting, stick and button inputs or landing distance. ⚠️ **Note:** The discrete-GPU tag is only a desktop proxy; it does not guarantee a non-Steam-Deck PC or performance well above 60 fps. ⚠️ **Note:** The alternative does not perform all requested jumps or verify that its picture follows a backflip landing; the save does not establish sword ownership. ⚠️ **Note:** The farm cannot run the separate GCC unit test or measure Link's landing position. What it could test instead: The alternative plan builds main and the PR on a Linux discrete-GPU PC, then exercises movement in child Hyrule Field at uncapped and 60 fps, with two runs per side. It records an unpaired picture after an attempted backflip and compares p99 frame time in a subsequent stationary segment; a crash, hang, or p99 increase over 10% fails. The lift builds are also timed. This alternative cannot establish the requested jump-frame performance or landing behavior. A member of `BigBeans` can comment `@Beanstalk <new words>` to ask for something else, or `@Beanstalk test it anyway` to run the plan regardless.
Author
Member

Measured: adult Link and the other moves above 60 (21 Nov)

A move probe (control bridge, kokiri-start save, headless; Windows 11 Pro 26200, RTX 4070 SUPER, Ryzen 9 9950X3D with SMT
off), cap 60 and Uncapped (99-120 fps) in each launch, two launches a build, the cap order swapped in the second: this head
a0e9b5eb built on main @ 9dd41326, against main @ 66dc0a51. Adult Link from the Debug tab's age switch, at the Hyrule Field
spot of the slope runs.

main @ 66dc0a51 this PR @ a0e9b5eb
the adult backflip's first hop (its height in the first 25-50 ms), cap 60 5 / 5 cm 5 / 5 cm
the same, Uncapped 2 / 2 cm 5-6 / 5 cm

So the adult backflip has the child's bug on main (from the same spot it lands 4 % short above 60, 2.25 / 2.27 m against
2.36 m, with one takeoff), and this change restores its first hop. Its distance on this head was not measured from the same
spot: the adult side hops before it branch at both caps (the first one 4.1 or 1.8 m), so the backflip started elsewhere.

The other moves the repository's saves reach move as at 60 on both builds: the camera turned by the right stick (108.6-108.8
deg/s) and recentred on Z (0.24-0.26 s), the Z sidestep right and left and the Z backpedal (within 1 %), Death Mountain Trail
up and down (within 0.5 %), running off the Goron City ledge (a plain fall, no hop: 4.46-4.51 m along at landing at both
caps), the adult run. The description's Tested, Measurements and Still to test are updated; a jump attack and the horse stay
by hand (no sword or horse in the repository's saves).

Measured: adult Link and the other moves above 60 (21 Nov) A move probe (control bridge, `kokiri-start` save, headless; Windows 11 Pro 26200, RTX 4070 SUPER, Ryzen 9 9950X3D with SMT off), cap 60 and Uncapped (99-120 fps) in each launch, two launches a build, the cap order swapped in the second: this head `a0e9b5eb` built on main @ 9dd41326, against main @ 66dc0a51. Adult Link from the Debug tab's age switch, at the Hyrule Field spot of the slope runs. | | main @ 66dc0a51 | this PR @ a0e9b5eb | |---|---|---| | the adult backflip's first hop (its height in the first 25-50 ms), cap 60 | 5 / 5 cm | 5 / 5 cm | | the same, Uncapped | 2 / 2 cm | 5-6 / 5 cm | So the adult backflip has the child's bug on main (from the same spot it lands 4 % short above 60, 2.25 / 2.27 m against 2.36 m, with one takeoff), and this change restores its first hop. Its distance on this head was not measured from the same spot: the adult side hops before it branch at both caps (the first one 4.1 or 1.8 m), so the backflip started elsewhere. The other moves the repository's saves reach move as at 60 on both builds: the camera turned by the right stick (108.6-108.8 deg/s) and recentred on Z (0.24-0.26 s), the Z sidestep right and left and the Z backpedal (within 1 %), Death Mountain Trail up and down (within 0.5 %), running off the Goron City ledge (a plain fall, no hop: 4.46-4.51 m along at landing at both caps), the adult run. The description's Tested, Measurements and Still to test are updated; a jump attack and the horse stay by hand (no sword or horse in the repository's saves).
HumanBean deleted branch fix/downhill-contact-fps 2026-11-21 17:24:44 +00:00
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!2071
No description provided.