Skip to content
Skills Library
Programming · Building & coding

responsive-input-timing

/responsive-input-timing

Use for jump buffering, coyote time, subframe input edges and fixed-timestep input replay; not browser device bindings.

Licence
MIT
Last repository change
30.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
15
Scripts
3
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 3 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: examples/platformer-integration.mjs, src/timing.mjs, tests/timing.test.mjs

What it does and when to use it

Use for jump buffering, coyote time, subframe input edges and fixed-timestep input replay; not browser device bindings.

Original author description

Use for jump buffering, coyote time, subframe input edges and fixed-timestep input replay; not browser device bindings.

How it works

  1. Implementation procedure
  2. Semantics and edge cases
  3. Files
  4. Boundaries
Original SKILL.md headings · 35 lines, 484 words
SKILL.md preview
---
name: responsive-input-timing
description: Use for jump buffering, coyote time, subframe input edges and fixed-timestep input replay; not browser device bindings.
---
# Responsive Input Timing (v1.0.0)

This skill owns **event timestamps, short buffering, coyote windows, consume-once edges and replay**. It NEVER changes velocity, gravity or character physics directly; expose a jump request to the existing controller and preserve its solver. It does not replace the `browser-input-action-system`, which captures physical input, nor `game-feel-event-orchestration`, which owns time-scale feedback.

## Implementation procedure

1. Identify one monotonic clock and simulation/update order. Convert timestamps at the system boundary rather than mixing `performance.now()`, seconds from physics simulation and wall clock milliseconds.
2. Have the action system capture each browser down/up as edge with a timestamp. **Do not require the button to still be held by the next fixed tick**. Forward to `FixedStepEdgeQueue` before simulation.
3. For platformer jump use `JumpAssist({bufferMs:120,coyoteMs:100})`; tune actual windows by playtest, not by frame count. `press(time,id)` stores unique input event ID; `tryConsume(time)` returns a single request if grounded or inside grace period; `setGrounded(time,bool)` updates the grounded state.
4. Call `tryConsume` once per simulated tick **after** processing buffered edges and grounded/landing state. Pass the returned request to the current movement controller (which owns velocity/impulse).
5. `release(time)` returns whether the jump was held, allowing the physics/controller to request upward velocity cut/modified gravity; this library does not select gravity values.
6. Cancel pending events on focus loss, pause, respawn, teleport or level transition as appropriate. The source queue's `cancel()` and `JumpAssist.cancel()` must both be invoked when dropping stale inputs.
7. Keep deterministic ordering: events in the same time domain, stable IDs, monotonic times. Use `InputTimeline` to capture and replay logical events, not browser event objects containing nonserializable properties.
8. Test `node --test tests/*.test.mjs` and `tsc --noEmit -p tsconfig.json`, then test against target physics with real platform collision timing.

## Semantics and edge cases

- Buffer window is inclusive at its boundary; an input expires strictly after `bufferMs`. Coyote window also includes its boundary. Both require nonnegative finite timestamps.
- Consume-once is enforced for a jump. An additional jump is gated until a **new ground contact**. Multiple different presses can replace pending jump; a configurable jump queue policy may be required by genre.
- A second jump in midair (double jump) is a **separate action/ability**; do not bypass the re-arming gate to simulate it.
- `FixedStepEdgeQueue.capture` validates monotonic arrival timestamps and `drainThrough(tickTime)` never repeats processed edges. Events arriving out of timestamp order must be normalized upstream or rejected.
- `InputTimeline` rejects duplicate event IDs and records events in order. `replay(handler)` is pure replay of event payloads; deterministic physics requires deterministic solver, random state and fixed timestep as well.
- Variable-height jump and apex assistance are recommendations for the **movement controller**, not new features in this module.

## Files

- `src/timing.mjs` / `src/timing.d.mts`
- `tests/timing.test.mjs` with 30/60/144 FPS and short-tap tests
- `examples/platformer-integration.mjs`
- `references/clock-and-physics.md`

## Boundaries

Integration requires test-scene timing and gameplay feel playtests. Pure test success is not proof of low-latency physical input on the display or of deterministic physics.
Files in this package (15)
  • CHANGELOG.md 1 KB
  • LICENSE 1 KB
  • PROVENANCE.md 1 KB
  • SKILL.md 4 KB
  • TESTING.md 1 KB
  • VERSION 1 KB
  • tsconfig.json 1 KB
  • attribution/upstream/LICENSE 11 KB
  • attribution/upstream/NOTICE 1 KB
  • examples/platformer-integration.mjs 1 KB
  • references/clock-and-physics.md 2 KB
  • src/timing.d.mts 1 KB
  • src/timing.mjs 4 KB
  • tests/timing.test.mjs 4 KB
  • typecheck/example.mts 1 KB

Versions

The database has no other skills named responsive-input-timing.

Database snapshot: 13.11.2026 · package version c3296de0faee (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100input-systems
    Architect game input — action mapping (abstracting keys into named actions), rebinding with conflict detection and persistence, multi-device support (keyboard, gamepad, touch), analog deadzones, and feel features like input buffering and coyote time, plus accessibility.…
  • 100input-systems
    Architect game input — action mapping (abstracting keys into named actions), rebinding with conflict detection and persistence, multi-device support (keyboard, gamepad, touch), analog deadzones, and feel features like input buffering and coyote time, plus accessibility.…
  • 100godot-characterbody-2d
    Expert patterns for CharacterBody2D including platformer movement (coyote time, jump buffering, variable jump height), top-down movement (8-way, tank controls), collision handling, one-way platforms, and state machines. Use for player characters, NPCs, or enemies. Trigger…
  • 100input-patterns
    Game input code patterns: Godot InputMap actions, a scaled radial deadzone, jump buffer with coyote time, rebinding serialization, a mobile virtual joystick, and gamepad rumble. Use when implementing controls, remapping, or controller feel.
  • 100platformer
    Build a 2D platformer: run/jump control with coyote time, jump buffering, and variable jump height, wall slide and wall jump, plus tiled levels and hazards. Use for a platformer or Mario/Celeste-like, or tuning jump feel.
  • 100platformer
    Build a 2D platformer: run/jump control with coyote time, jump buffering, and variable jump height, plus tiled levels and hazards. Use for a platformer or Mario/Celeste-like, or tuning jump feel.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.