| # | Time (s) | Window (f) | ms |
|---|
| # | Time (s) | Time (%) | Window | ms | pass | reach | bits (G) | time lost (T) |
|---|
An input with an Nₕ-frame window lasts wₕ = Nₕ / fps seconds.
A player with precision L = 1/σ (σ = timing error in seconds) hits it with
pₕ = erf( (½·wₕ·L) / √2 ).
Clear chance P(C) = ∏ pₕ, reach chance rₕ = ∏₃₂ₓₖ p₋.
Time per attempt E[T₉] = tₙ·P(C) + ∑ tₕ·rₕ·(1−pₕ),
expected time E[T╕] = E[T₉] / P(C). L* is the L where
E[T╕] hits the target. Solve for Time does the reverse.
Histogram spreads inputs evenly across the level. List uses exact positions. % is a share of the level length. Frames are converted with Game FPS.
A window of - always passes but still counts for timing (with CPS on, it gets the run's largest
window + 1). The # column is the input index used by Fatigue and CPS, so gaps in numbering mean skipped clicks.
Respawn time adds to every attempt.
Run scores only the inputs in the range, shifted to start at 0. Exclude drops windows at or above the threshold. It runs before the run slice and doesn't change level length.
Each one scales an input's window: Nerve e^(−k·tₕ), Fatigue
e^(−k·i), CPS (4/max(1,2c))^k with c = local clicks/sec.
Defaults are the official calculator's constants. CPS is marked unreliable there too.
G = −log₂ P(C) = ∑ −log₂ pₕ bits. Attempts ≈ 2ᵍ,
so +1 bit doubles the grind. Segments add: G(A+B) = G(A) + G(B). Measured at a fixed precision so
levels compare. Ignores position and respawn.
T = E[T╕] = tₙ + respawn/P(C) + ∑ costₕ, with
costₕ = tₕ·rₕ·(1−pₕ) / P(C). Unlike G, it cares where an input
sits: a miss late in the run wastes more time. Not additive.
pass and reach are at L*, bits at G's precision, time lost at T's.
Compatible with the official calculator. Frame positions are converted with gameFps.