The obvious implementation is two jump files: a short one for a tap, a long one for a hold. The player presses and releases quickly, the game plays the short file; the player holds, the game plays the long file. It works in a prototype and fails in a game with variable jump height, because variable jump height is not two states. It is a continuum.
A player who holds the button for 120 ms is not making a “short jump” or a “full jump.” They are making a jump with a specific duration, and the sound has to match that duration, not snap to one of two pre-recorded options. The sections below work through why the two-file approach breaks, and how a single parameterized system handles the whole range without producing a sound that lurches between two identities.
Two Files Is a Binary Solution to a Continuous Problem
Variable jump height works by letting the player’s button release cut the upward velocity. Hold longer, rise higher; release early, rise less. The jump duration is a continuous value between the minimum hop and the maximum jump, and the player can produce any value in between.
A two-file system quantizes that continuum into two buckets. A jump that lasts 0.15 seconds gets the “short” file; a jump that lasts 0.35 seconds gets the “long” file. The problem is not the quantization itself — players rarely notice a small mismatch between sound length and jump length. The problem is the transition. At the threshold where the game switches from the short file to the long file, the sound jumps from one identity to another with no intermediate state. A player who holds the button just past the threshold hears a sound that is clearly the “full jump” sound, even though their jump is only marginally longer than the one that produced the “short hop” sound.
The result is a sound that feels like it is guessing. The player is making a continuous adjustment, and the audio is snapping between two answers. The double jump guide covers the case where two jumps are genuinely different resources; a short hop and a full jump are not different resources. They are the same resource spent for different durations.
The System That Works: One Impulsion, One Motion, Weighted by Jump Length
The clearest documented implementation of a duration-aware jump sound comes from CRI Middleware’s analysis of a 2D platformer jump. The jump is split into two assets: an impulsion and a motion.
The impulsion is short — 75 to 100 ms — with the pitch only slightly rising. The motion is at least 1 second long, and its pitch rises one octave. Both are generated from a square wave oscillator.
The key is not the two assets themselves. It is the AISAC curves that control how they interact as the jump gets longer. The pitch curve rises from 0 to 1,200 cents (one octave). The release time spans 50 to 500 ms. And the pre-delay goes from 75 ms down to 25 ms.
The pre-delay is the parameter that solves the short-hop problem. A longer pre-delay — 75 ms — is used to emphasize the initial impulsion when the jump is short. As the jump gets longer, the pre-delay becomes shorter — down to 25 ms — and the volume of the impulsion is lowered to focus on the motion.
In other words, a short hop is mostly impulsion with very little motion; a full jump is mostly motion with the impulsion pushed back and turned down. The transition between them is not a file switch. It is a continuous crossfade driven by the jump’s duration, and the player hears a sound that grows with the jump instead of snapping between two options.
What a Short Hop Needs From the Sound: Punch, Not Rise
A short hop is a brief, low commitment. The character leaves the ground and comes back quickly. The sound has to confirm the input and then get out of the way.
The impulsion-led weighting does exactly that. The sound is dominated by the initial attack — the push — and the motion layer is barely present. The result is a short, punchy sound that reads as “a small jump happened” without suggesting that the character is going to travel.
A separate reference from 8bit-sfx shows the same pattern in the jump presets. A “snappy tail” jump at 0.154 seconds and a “floaty tail” jump at 0.347 seconds are both upward square sweeps, but the snappy version is shorter and tighter, while the floaty version has a longer tail that suggests more airtime. The distinction is not the waveform or the pitch range; it is how much of the sound is after the initial hit.
A working short-hop sound sits in the 80–150 ms range, with the motion layer either absent or weighted low enough that it does not read as a sustained rise. The SFX duration guide gives the category context; the short-hop case is the low end of the jump range, not a separate category.
What a Full Jump Needs: A Sense of Travel
A full jump is a commitment. The character is going to be in the air long enough that the player needs to feel the arc, not just the launch. The sound has to carry that sense of travel.
The motion-led weighting does that. The impulsion is still present — the player still needs to know the input registered — but it is pushed back and turned down. The motion layer carries the rise, and its pitch climbs a full octave over the course of the jump. The result is a sound that feels like it is still happening while the character is rising, rather than a sound that fired once and ended.
The duration of the motion layer is the parameter that distinguishes a full jump from a short hop in this system. A short hop has a motion layer that is barely present or very short; a full jump has a motion layer that lasts long enough to cover the rise. The CRI example stops the motion at about 150 ms on the timeline, and extends it with the release time as the jump gets longer . That is the mechanical difference between the two sounds: not a different file, but a different amount of motion.
The Parameters That Actually Need to Change Between the Two
The table below gives the values that distinguish a short hop from a full jump in a parameterized system. The left column is the parameter; the middle and right columns are the two ends of the range.
| Parameter | Short hop | Full jump |
|---|---|---|
| Dominant layer | Impulsion | Motion |
| Pre-delay | ~75 ms (emphasises the push) | ~25 ms (motion arrives sooner) |
| Impulsion volume | Full | Lowered |
| Motion release | Short (~50 ms) | Long (~500 ms) |
| Total duration | ~80–150 ms | 200 ms+ with the motion tail |
The values are not independent. Shortening the pre-delay without lowering the impulsion volume makes the full jump sound like a short hop with a longer tail. Lowering the impulsion without extending the motion release makes the full jump sound like a short hop that faded out. The two changes have to happen together, because they are two expressions of the same weighting shift.
What to Check When the Two Ends Are Working but the Middle Is Not
The most common failure in a parameterized system is that the extremes sound correct and the middle sounds wrong. A short hop is punchy, a full jump is expansive, and a jump held for 0.25 seconds sounds like neither.
- Play ten jumps at different hold durations and listen for a “step.” If the sound changes character abruptly at any point in the range, the curves are not linear or the weighting is switching too sharply.
- Check the impulsion at the middle of the range. If the impulsion is still prominent at a jump duration where the motion layer has already grown, the sound will feel like it has two attacks. The impulsion should recede as the motion takes over.
- Check the motion at the short end. If the motion layer is audible at a hop duration, the short hop will sound like a full jump that was cut off. The motion should be absent or near-absent at the minimum duration.
- Listen to a jump that is released very late. If the motion layer has already ended before the character lands, the full jump will sound like it is falling silent in the air. The motion release has to scale with the jump duration, not be a fixed length.
The pitch variation guide covers the separate question of randomizing pitch across instances; the short-hop/full-jump distinction is a within-instance parameter, not a between-instance one. A jump should not randomize between “short hop” and “full jump” — it should scale continuously with the input.