Controls & camera

Rhythm lane hit

rhythm-lane-hit · an adoption of Input forgiveness, version 1

Tests included

Use in your game

Opens the authoring tool with these answers and settings already filled in. You still add your game's own rules and tuning.

What is in the ZIP

The ZIP holds the adoption and its acceptance tests. In the authoring tool, choose Add contract and pick this ZIP. If you keep your design as files, put them in contracts/.

The contract behind it

Covers inputs accepted just before the game allows the action, just after it stops allowing it, or near a target moment such as a beat or impact. It records which game actions receive that help, what arms each case, and when a saved action fires. Physical controls, ordinary action rules, and spatial nudges such as corner correction stay elsewhere.

Read the full Input forgiveness contract →

Questions

The supplied answer is marked on each question. Pick other answers to see what changes. Nothing is saved here: the ZIP and the authoring tool use the supplied answers.

When several helped inputs come due together, which ones does the game try?

Asked when
the late input windows list has at least one row, or the input buffers list has at least one row, or the target moment windows list has at least one row.
If not asked
No forgiveness row can make an input due.
Choices for When several helped inputs come due together, which ones does the game try?
The game tries every helped input that comes due. A twin-stick hero may dodge and fire at the same moment.

Every ready forgiven input is submitted once as an action proposal. Event resolution owns their order and the game rules may still reject incompatible actions.

One ready input wins by a fixed game priority. A farm tool may water before planting when both become ready.

Exactly one ready forgiven input is submitted. The matching competition-rules row supplies one total priority over every input that can be ready in that situation.

Supplied answer Two helped inputs can never come due together. A one-button rhythm lane has at most one note action at a beat.

The adoption guarantees that no reachable game state presents two ready forgiven inputs at one moment. Reaching such a state invalidates the design claim.

Why this is asked

A landing, beat, or recovery end can make several helped inputs ready. The game must decide which ones to try.

Numbersno numbers

This contract has no numbers to set.

Rulesno rules

A rule is a check between the numbers. Validation reports a rule that fails.

This contract has no rules between its numbers.

Lists4 lists

Each list holds the rows this adoption supplies. A list can be empty.

Late input windows

late-input-windows

This adoption declares no late input windows.

Input buffers

input-buffers

This adoption declares no input buffers.

Target moment windows

target-moment-windows

IdActionAction declared inTarget moment declared inArms when declared inWindow declared inResult declared inCancels when declared in
lead-note-hithit-noterhythm.hit-note-actionrhythm.lead-note-target-beatrhythm.lead-note-input-associationrhythm.lead-note-two-sided-hit-windowrhythm.lead-note-timing-graderhythm.lead-note-cancellation

Competition rules

competition-rules

This adoption declares no competition rules.

Test inputsscope and seeds

Some tests need a scope or seeds from the adoption before they can run.

This adoption supplies none; every test uses its defaults.

Acceptance tests24 tests apply

The contract comes with 49 tests. A test that runs once per row is counted once for each row. Tests that do not apply to these answers are still listed, with the reason.

forgiveness-vocabulary-and-openness

input forgiveness uses game-facing input and cited openness

scenarioonce

Applies to rhythm-lane-hit.

For a declared row, an action input is the game-facing event after Control options maps a physical control; device identity does not change settlement. Ordinary permission is the action's legal state before forgiveness, and a press uses the edge named by the cited action rule. Openness comes from the agreeing Timed window adoption where one exists, otherwise from the cited Fixed timing rule. A family this adoption does not declare asserts nothing in the clause that names it.

Test steps and diagnostics
Given

a physical control mapped through Control options to an action input that reaches a declared forgiveness row

When
  • the row reads ordinary permission, its input edge, and whether its window instance is open
Then
  • the action input is the game-facing event after mapping, independent of physical device identity
  • ordinary permission is the action's legal state before forgiveness
  • the press arrives on the edge named by the cited action rule, including a release edge where that rule names one
  • openness comes from the agreeing Timed window adoption where one exists and otherwise from the row's cited Fixed timing rule
  • an accepted late or target input, or a saved press whose firing event has arrived, is one ready forgiven input
  • a family this adoption does not declare asserts nothing in the clause that names it
Diagnostics
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-window-instances
  • rhythm-lane-hit-ready-set

unmatched-input-receives-no-forgiveness

an unmatched action input receives no forgiveness

scenarioonce

Applies to rhythm-lane-hit.

An action input with no matching row in the current situation receives no forgiveness. Ordinary permission alone decides whether the action is submitted.

Test steps and diagnostics
Given

an action input with no matching late-input-windows, input-buffers, or target-moment-windows row in the current situation

When
  • the game receives that action input
Then
  • ordinary permission alone decides whether the action is submitted
  • the adoption creates no ready forgiven input, saved press, or target grade for it
Diagnostics
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-ready-set
  • rhythm-lane-hit-waiting-press-state

empty-row-families-create-no-forgiveness

empty row families create no forgiveness state

scenarioonce

Applies to rhythm-lane-hit.

An empty late-input-windows set keeps no action available after ordinary permission ends; an empty input-buffers set means no early press waits for an action to become ordinarily permitted; an empty target-moment-windows set forgives no input near a target moment; and an empty competition-rules set declares no priority. Where the named set has a row, that clause asserts nothing. If all three forgiveness families are empty, no forgiveness row can make an input due and the competition-rules description requires no competition rows; any row is a defect this test fails by construction. Where any forgiveness family has a row, that last clause asserts nothing.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption document and its row sets

When
  • each empty row set's declared consequence is read
Then
  • where late-input-windows is empty, no action remains available through forgiveness after ordinary permission ends; where a row exists, this clause asserts nothing
  • where input-buffers is empty, no early press waits for an action to become ordinarily permitted; where a row exists, this clause asserts nothing
  • where target-moment-windows is empty, no input is forgiven because it falls near a target moment; where a row exists, this clause asserts nothing
  • where competition-rules is empty, no competition priority rule is declared; where a row exists, this clause asserts nothing
  • where all three forgiveness row families are empty, no forgiveness row can make an input due; where any family has a row, this clause asserts nothing
  • where all three forgiveness row families are empty, competition-rules has no rows and any row is a defect this test fails by construction; where any family has a row, this clause asserts nothing
Diagnostics
  • rhythm-lane-hit-declaration-record

late-window-arms-on-cited-event

Row.id arms one late window on its cited event

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

target-instance-arms-on-cited-event · lead-note-hit

lead-note-hit creates one instance for each cited target

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

For every target moment at rhythm.lead-note-target-beat, the event at rhythm.lead-note-input-association creates one separate lead-note-hit target instance under rhythm.lead-note-two-sided-hit-window before and independently of input.

Test steps and diagnostics
Given

two distinct target moments named by rhythm.lead-note-target-beat

When
  • the creating event at rhythm.lead-note-input-association occurs for each target before any associated action input
Then
  • each target receives one separate lead-note-hit target instance under rhythm.lead-note-two-sided-hit-window
  • each instance exists before and independently of its associated input
Diagnostics
  • rhythm-lane-hit-arming-log
  • rhythm-lane-hit-window-instances

buffer-arms-on-qualifying-press

Row.id creates no instance before its qualifying press

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

receipt-maps-before-settlement

input receipt maps the control before reading forgiveness

scenarioonce

Applies to rhythm-lane-hit.

Control options maps a physical control before forgiveness reads ordinary permission and matching rows. Device identity does not change settlement. A control already held when a late or target row arms creates no action input unless its cited action rule defines one; without either family, that observation asserts nothing.

Test steps and diagnostics
Given

two physical devices mapped by Control options to the same action input, plus a control already held when a late or target row arms where the adoption can construct one

When
  • the game receives each mapped input and observes the already-held control
Then
  • both mapped action inputs read the same ordinary permission and matching rows regardless of device identity
  • the already-held control creates no action input at arming unless the cited action rule explicitly defines one
  • where the adoption has no late or target row, the already-held observation asserts nothing
Diagnostics
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-arming-log

receipt-family-order

target, late, buffer, and ordinary receipt keep their fixed order

scenarioonce

Applies to rhythm-lane-hit.

A receipt evaluates target rows first whether ordinary permission exists or not. If none accepts and permission exists, it submits the ordinary attempt without forgiveness. Without permission, late rows run next and a buffer captures only if neither immediate family accepts. A family this adoption does not declare asserts nothing in the clause that names it.

Test steps and diagnostics
Given

action-input receipts that exercise every forgiveness family the rhythm-lane-hit adoption declares

When
  • ordinary permission is present in one receipt and absent in another
Then
  • every matching target row is evaluated regardless of ordinary permission before any late or buffer row
  • ordinary permission prevents late and buffer evaluation but does not prevent target evaluation
  • if no target row accepts and ordinary permission exists, the ordinary attempt is submitted without forgiveness and the receipt ends
  • with no ordinary permission, late rows run before buffer rows, and a buffer captures only if neither immediate family accepts
  • a family absent from this adoption asserts nothing in the clauses that name it
Diagnostics
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-submission-log
  • rhythm-lane-hit-waiting-press-state

target-input-accepts-and-grades · lead-note-hit

lead-note-hit accepts and grades only an open, otherwise-legal attempt

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

While rhythm.lead-note-two-sided-hit-window records a lead-note-hit target instance open, including its cited early and late inclusive moments, an otherwise-legal hit-note input is accepted, becomes ready now, and is graded by rhythm.lead-note-timing-grade. An otherwise-illegal input while open is not accepted, becomes no ready forgiven input, receives no result, and gains no ordinary permission. An input before the cited early bound or after that target instance closes is not accepted. The first accepted input settles that target instance unless the cited result rule declares otherwise, and acceptance ends the receipt.

Test steps and diagnostics
Given

four associated hit-note inputs for separate lead-note-hit target instances: an otherwise-legal input while rhythm.lead-note-two-sided-hit-window records its own target instance open, including its cited early and late inclusive moments, an otherwise-illegal input while that target instance is open, an otherwise-legal input after that target instance closes, and an otherwise-legal input before the cited early bound

When
  • each input is evaluated against its target instance
Then
  • the open otherwise-legal input is accepted, becomes ready now, and receives the result at rhythm.lead-note-timing-grade
  • the otherwise-illegal input while open is not accepted, becomes no ready forgiven input, and receives no result at rhythm.lead-note-timing-grade; the row grants it no ordinary permission
  • the closed instance accepts and grades nothing
  • the input before the cited early bound is not accepted by lead-note-hit
  • the first accepted input settles its target instance unless rhythm.lead-note-timing-grade declares a different settlement
  • acceptance ends that action-input receipt before late or buffer evaluation
Diagnostics
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-ready-set
  • rhythm-lane-hit-target-grades
  • rhythm-lane-hit-window-instances

late-input-accepts-only-while-open

Row.id accepts through its cited last moment and not later

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

buffer-captures-one-press

Row.id stores one press and follows Row.waiting press

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

late-window-clears-on-four-ends

Row.id ends on execution, permission, close, or early clearing

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

buffer-fires-or-clears-at-first-boundary

Row.id fires once at its first cited event or clears without firing

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

target-instance-stops-accepting · lead-note-hit

lead-note-hit accepts nothing after close, settlement, or early clearing

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

lead-note-hit accepts nothing for a target instance after rhythm.lead-note-two-sided-hit-window closes it, rhythm.lead-note-timing-grade settles it, or rhythm.lead-note-cancellation ends it early. Openness is read at the recorded input moment.

Test steps and diagnostics
Given

three lead-note-hit target instances, one closed by rhythm.lead-note-two-sided-hit-window, one settled under rhythm.lead-note-timing-grade, and one ended by rhythm.lead-note-cancellation

When
  • an otherwise-legal associated hit-note input reaches each instance afterward
Then
  • none of the three instances accepts the later input or creates another target grade
  • the recorded input moment, not a later update, decides whether the cited window was open
Diagnostics
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-window-instances
  • rhythm-lane-hit-target-grades

ready-input-exists-once

each ready forgiven input exists once

scenarioonce

Applies to rhythm-lane-hit.

A stored press or accepted input contributes one ready forgiven input, and repeated updates create no copy. If two adoptions produce ready inputs at one moment, each settles independently and both selected sets are submitted together; where that case cannot occur, the clause asserts nothing.

Test steps and diagnostics
Given

a stored press or accepted input that becomes ready, plus two adoptions producing ready inputs at one moment where the game can construct that case

When
  • the game updates the ready state repeatedly and settles the moment
Then
  • the same stored press or accepted input contributes exactly one ready forgiven input
  • a repeated update creates no copy
  • where two adoptions contribute, each settles independently and the inputs selected by both are submitted together
  • where no shared-adoption moment can occur, the shared-adoption clause asserts nothing
Diagnostics
  • rhythm-lane-hit-ready-set
  • rhythm-lane-hit-submission-log

all-ready-actions-submit-every-input

all-ready-actions submits every ready input once

scenarioonce

Does not apply to rhythm-lane-hit: ready together is cannot coincide, not all ready actions.

declared-priority-submits-one-winner

declared-priority submits one stable winner

scenarioonce

Does not apply to rhythm-lane-hit: ready together is cannot coincide, not declared priority.

cannot-coincide-invalidates-two-ready-inputs

cannot-coincide rejects a reachable pair of ready inputs

scenarioonce

Applies to rhythm-lane-hit.

Under cannot-coincide, no reachable game state has two ready forgiven inputs at one moment. One observed pair invalidates the design claim; this contract does not choose a winner.

Test steps and diagnostics
Given

the adoption's reachable-state claim for ready forgiven inputs

When
  • the audit searches for a game moment with two ready forgiven inputs
Then
  • no reachable game state contains that pair
  • one observed pair invalidates the design claim rather than selecting an implicit winner
Diagnostics
  • rhythm-lane-hit-ready-set
  • rhythm-lane-hit-coincidence-violation

selected-inputs-stop-at-proposal-boundary

selected inputs become proposals at this moment

scenarioonce

Applies to rhythm-lane-hit.

A selected input becomes an action proposal at the current game moment. Event resolution owns same-moment proposal order, and the action's Fixed rules own cost, effect, and rejection. This contract stops at submission and does not force a conflicting action to succeed.

Test steps and diagnostics
Given

one or more inputs selected for submission

When
  • input forgiveness submits them
Then
  • each selected input enters Event resolution as an action proposal at the current game moment
  • the input-forgiveness trace performs no ordering of proposals that share the moment
  • cost, effect, conflict rejection, and proposal order are absent from input-forgiveness settlement and remain owned by the cited action rules and Event resolution
Diagnostics
  • rhythm-lane-hit-submission-log
  • rhythm-lane-hit-ready-set

buffer-clears-after-submission

Row.id clears after submission

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

buffer-clears-after-competition-loss

Row.id clears after competition loss

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: ready together is cannot coincide, not declared priority.

late-window-clears-after-submission

Row.id clears on submission

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

late-window-survives-competition-loss

Row.id is not ended by a competition loss

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: ready together is cannot coincide, not declared priority.

target-input-after-submission · lead-note-hit

lead-note-hit leaves no saved press after submission

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

A selected lead-note-hit target input leaves no saved press after submission.

Test steps and diagnostics
Given

one input accepted by lead-note-hit and selected for submission

When
  • the selected target input is submitted
Then
  • the target input leaves no saved press after submission
Diagnostics
  • rhythm-lane-hit-submission-log
  • rhythm-lane-hit-waiting-press-state

target-instance-after-competition-loss

Row.id remains open after competition loss until settled or closed

scenarioper target-moment-windows row

Does not apply to rhythm-lane-hit: ready together is cannot coincide, not declared priority.

held-control-after-buffer-fire

Row.id follows Row.held after fire after its action fires

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

rejected-proposal-restores-nothing

a rejected proposal restores no forgiveness state

scenarioonce

Applies to rhythm-lane-hit.

Rejecting a submitted action proposal restores no cleared forgiveness state. A new attempt needs a new qualifying arming event or press. Rejection consequences belong to Event resolution and assert nothing here.

Test steps and diagnostics
Given

a submitted forgiven action proposal after the submission-time clearing for its family

When
  • the cited action rule or Event resolution rejects the proposal
Then
  • the cleared forgiveness state remains absent
  • a new attempt appears only after a new qualifying arming event or press
  • the consequences of rejection assert nothing in this contract
Diagnostics
  • rhythm-lane-hit-submission-log
  • rhythm-lane-hit-clearing-log
  • rhythm-lane-hit-window-instances
  • rhythm-lane-hit-waiting-press-state

forgiveness-authority-order

the forgiveness authority order never rewrites earlier moments

scenarioonce

Applies to rhythm-lane-hit.

Arming, input mapping, ordinary permission, target acceptance, late acceptance, buffer capture, repeated-press choice, open and early-clearing state, firing, competition, Event resolution order, action rules, clearing, and held-input renewal remain in that authority order. No later stage rewrites an earlier input moment or target moment. A stage absent from the case asserts nothing.

Test steps and diagnostics
Given

a receipt and settlement trace with distinguishable arming, mapped input, ordinary permission, acceptance or capture, open state, firing, competition, submission, action result, clearing, and held-input records where those stages occur

When
  • the trace is compared with the mechanism's authority order
Then
  • each stage reads the result of every earlier applicable stage in the listed order
  • no later stage rewrites an earlier input moment or target moment
  • a stage absent from the constructed case asserts nothing
Diagnostics
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-arming-log
  • rhythm-lane-hit-ready-set
  • rhythm-lane-hit-submission-log
  • rhythm-lane-hit-clearing-log

row-families-do-not-overlap

declaration check: no family has two rows matching one input

scenarioonce

Applies to rhythm-lane-hit.

This declaration check reads the adoption and its cited prose, not the running game. The contract makes two rows of one family matching one input in the same situation an invalid adoption rather than an implicit choice. An overlapping pair is a defect this test fails by construction. For a family with fewer than two rows, its pair comparison asserts nothing.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and its cited prose, not the running game

When
  • a reviewer compares every pair of rows within late-input-windows, input-buffers, and target-moment-windows
Then
  • no two rows in one family can match one action input in the same situation
  • an overlapping pair is a defect this test fails by construction; for a family with fewer than two rows, its pair comparison asserts nothing
Diagnostics
  • rhythm-lane-hit-declaration-record

declared-priority-has-one-matching-rule

declaration check: declared-priority has one matching competition row

scenarioonce

Does not apply to rhythm-lane-hit: ready together is cannot coincide, not declared priority.

non-priority-answers-have-no-competition-rows

declaration check: non-priority answers declare no competition rows

scenarioonce

Applies to rhythm-lane-hit.

This declaration check reads the adoption, not the running game. The competition-rules description says rows exist only under declared-priority, so under all-ready-actions or cannot-coincide the set must be empty. Any row is a defect this test fails by construction.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption document, not the running game

When
  • a reviewer counts competition-rules rows
Then
  • competition-rules has no rows
  • any competition-rules row is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

no-external-rule-promises-forgiveness

declaration check: unmatched actions have no external forgiveness promise

scenarioonce

Applies to rhythm-lane-hit.

This declaration check reads the adoption and its cited prose, not the running game. The contract says no cited game rule outside these rows promises forgiveness for an unmatched action or input. Any such promise is a defect this test fails by construction.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and all prose it cites, not the running game

When
  • a reviewer searches outside these rows for a promise that an unmatched action or input receives forgiveness
Then
  • no cited game rule outside these rows promises forgiveness for an unmatched action or input
  • any such promise is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

late-action-citation-duty

declaration check: Row.id's action citation states its duty

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

late-arming-citation-duty

declaration check: Row.id's arming citation states its duty

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

late-window-citation-duty

declaration check: Row.id's window citation states its duty

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

late-cancellation-citation-duty

declaration check: Row.id's cancellation citation states its duty

scenarioper late-input-windows row

Does not apply to rhythm-lane-hit: late-input-windows has no rows.

buffer-action-citation-duty

declaration check: Row.id's action citation states its duty

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

buffer-arming-citation-duty

declaration check: Row.id's arming citation states its duty

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

buffer-window-citation-duty

declaration check: Row.id's window citation states its duty

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

buffer-firing-citation-duty

declaration check: Row.id's firing citation states its duty

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

buffer-cancellation-citation-duty

declaration check: Row.id's cancellation citation states its duty

scenarioper input-buffers row

Does not apply to rhythm-lane-hit: input-buffers has no rows.

target-action-citation-duty · lead-note-hit

declaration check: lead-note-hit's action citation states its duty

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

This declaration check reads the adoption and rhythm.hit-note-action, not the running game. The action-declared-in description requires the citation to identify hit-note as the row's action-input scope and name ordinary permission and the complete attempt; for the reserved all-actions spelling, it names these for every action in the set. A missing duty is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and the prose at rhythm.hit-note-action, not the running game

When
  • a reviewer checks the citation's meaning
Then
  • rhythm.hit-note-action identifies the row's action-input scope and names ordinary permission and the complete attempt; for the reserved all-actions spelling, it names these for every action in the set, as the action-declared-in description requires
  • a missing duty is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

target-moment-citation-duty · lead-note-hit

declaration check: lead-note-hit's target citation states its duty

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

This declaration check reads the adoption and rhythm.lead-note-target-beat, not the running game. The citation must name the target moment for lead-note-hit. A missing duty is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and the prose at rhythm.lead-note-target-beat, not the running game

When
  • a reviewer checks the citation's meaning
Then
  • rhythm.lead-note-target-beat names the target moment for lead-note-hit
  • a missing duty is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

target-arming-citation-duty · lead-note-hit

declaration check: lead-note-hit's arming citation states its duty

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

This declaration check reads the adoption and rhythm.lead-note-input-association, not the running game. The citation must name the event that creates each lead-note-hit target instance and every associated input event. A missing duty is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and the prose at rhythm.lead-note-input-association, not the running game

When
  • a reviewer checks the citation's meaning
Then
  • rhythm.lead-note-input-association names the event that creates each lead-note-hit target instance and every associated input event
  • a missing duty is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

target-window-citation-duty · lead-note-hit

declaration check: lead-note-hit's window citation states its duty

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

This declaration check reads the adoption and rhythm.lead-note-two-sided-hit-window, not the running game. The window-declared-in description requires the citation to state one outer window with early and late bounds of positive width, inclusive last moments, unit, clock, pause behaviour, and open-state test for lead-note-hit. A missing duty is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and the prose at rhythm.lead-note-two-sided-hit-window, not the running game

When
  • a reviewer checks the citation's meaning
Then
  • rhythm.lead-note-two-sided-hit-window states one outer window with early and late bounds of positive width, inclusive last moments, unit, clock, pause behaviour, and open-state test for lead-note-hit, as the window-declared-in description requires
  • a missing duty is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

target-result-citation-duty · lead-note-hit

declaration check: lead-note-hit's result citation states its duty

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

This declaration check reads the adoption and rhythm.lead-note-timing-grade, not the running game. The result-declared-in description requires the citation to state the result for an accepted lead-note-hit input, every grade boundary inside the outer window, and any departure from first-accepted settlement. A missing duty is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and the prose at rhythm.lead-note-timing-grade, not the running game

When
  • a reviewer checks the citation's meaning
Then
  • rhythm.lead-note-timing-grade states the result for an accepted lead-note-hit input, every grade boundary inside the outer window, and any departure from first-accepted settlement, as the result-declared-in description requires
  • a missing duty is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

target-cancellation-citation-duty · lead-note-hit

declaration check: lead-note-hit's cancellation citation states its duty

scenarioper target-moment-windows row

Applies to the lead-note-hit row.

This declaration check reads the adoption and rhythm.lead-note-cancellation, not the running game. The citation must name every event that stops a lead-note-hit target instance before its window closes or state that no extra event does. A missing duty is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics
Given

the rhythm-lane-hit adoption and the prose at rhythm.lead-note-cancellation, not the running game

When
  • a reviewer checks the citation's meaning
Then
  • rhythm.lead-note-cancellation names every event that stops a lead-note-hit target instance before its cited window closes or states that no extra event does
  • a missing duty is a defect this test fails by construction
Diagnostics
  • rhythm-lane-hit-declaration-record

competition-citation-duty

declaration check: Row.id's competition citation states its duty

scenarioper competition-rules row

Does not apply to rhythm-lane-hit: competition-rules has no rows.

forgiveness-holds

input forgiveness holds for the whole run

generalonce

Applies to rhythm-lane-hit.

Across every armed window, saved press, and target instance of the audited run, every forgiven input follows its row and cited rules; unmatched inputs receive no forgiveness; no row holds more than one press; no press is stored or fired twice; every competition follows its declaration; and rejection restores no cleared state. A case this adoption cannot construct asserts nothing.

Test steps and diagnostics
Holds

across every armed window, saved press, and target instance of the audited run, every forgiven input was accepted, stored, fired, submitted, or cleared exactly as its row and cited rules state; no unmatched input received forgiveness; no row held more than one press; no press was stored twice or fired twice; every competition selected as declared; no rejected proposal restored cleared forgiveness state; a case the adoption cannot construct asserts nothing

Seeds

["audit-a","audit-b"]

Scope

every armed window, saved press, and target instance of the audited run

Diagnostics
  • rhythm-lane-hit-arming-log
  • rhythm-lane-hit-input-receipt
  • rhythm-lane-hit-waiting-press-state
  • rhythm-lane-hit-window-instances
  • rhythm-lane-hit-ready-set
  • rhythm-lane-hit-submission-log
  • rhythm-lane-hit-clearing-log
  • rhythm-lane-hit-target-grades
JSONthe adoption as one file

The adoption file as supplied. Answers you try on this page are not written into it; to change an adoption, open it in the authoring tool.

{
  "contract": "input-forgiveness",
  "version": 1,
  "summary": "Covers inputs accepted just before the game allows the action, just after it stops allowing it, or near a target moment such as a beat or impact. It records which game actions receive that help, what arms each case, and when a saved action fires. Physical controls, ordinary action rules, and spatial nudges such as corner correction stay elsewhere.",
  "questions": {
    "ready-together": {
      "asks": "When several helped inputs come due together, which ones does the game try?",
      "rationale": "A landing, beat, or recovery end can make several helped inputs ready. The game must decide which ones to try.",
      "when": {
        "any": [
          {
            "row-count": {
              "late-input-windows": "non-empty"
            }
          },
          {
            "row-count": {
              "input-buffers": "non-empty"
            }
          },
          {
            "row-count": {
              "target-moment-windows": "non-empty"
            }
          }
        ]
      },
      "otherwise": "No forgiveness row can make an input due.",
      "options": {
        "all-ready-actions": {
          "meaning": "The game tries every helped input that comes due. A twin-stick hero may dodge and fire at the same moment.",
          "semantics": "Every ready forgiven input is submitted once as an action proposal. Event resolution owns their order and the game rules may still reject incompatible actions."
        },
        "declared-priority": {
          "meaning": "One ready input wins by a fixed game priority. A farm tool may water before planting when both become ready.",
          "semantics": "Exactly one ready forgiven input is submitted. The matching competition-rules row supplies one total priority over every input that can be ready in that situation."
        },
        "cannot-coincide": {
          "meaning": "Two helped inputs can never come due together. A one-button rhythm lane has at most one note action at a beat.",
          "semantics": "The adoption guarantees that no reachable game state presents two ready forgiven inputs at one moment. Reaching such a state invalidates the design claim."
        }
      }
    }
  },
  "declares": {
    "values": {},
    "rows": {
      "late-input-windows": {
        "description": "Actions accepted just after ordinary permission ends, such as a platformer jump after leaving walkable ground.",
        "when-empty": "No action remains available through input forgiveness after its ordinary permission ends.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as jump-after-ground."
          },
          "action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game action receiving late forgiveness, such as jump. The reserved all-actions spelling covers the game's complete action set."
          },
          "action-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the action, its ordinary permission, and its complete effect. For the reserved all-actions spelling, it names these for every action in the set."
          },
          "arms-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming every transition that starts this late case and every similar transition that does not. A platformer may name walking off ground and exclude jumping from it."
          },
          "window-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The game's Fixed timing rule for this late window, including its positive duration, unit, inclusive last moment, clock, pause behaviour, and open-state test."
          },
          "cancels-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming every game event that ends this forgiveness before the cited window closes, or stating that no extra event does."
          }
        }
      },
      "input-buffers": {
        "description": "Early presses saved until an action first becomes ordinarily permitted, such as dodge pressed during attack recovery.",
        "when-empty": "No early press waits for an action to become ordinarily permitted.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as dodge-during-recovery."
          },
          "action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game action whose early press may wait, such as dodge. The reserved all-actions spelling covers the game's complete action set."
          },
          "action-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the action, its ordinary permission, and its complete effect. For the reserved all-actions spelling, it names these for every action in the set."
          },
          "arms-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the accepted early states, the excluded states, and the matching action input. A soulslike may accept dodge during recovery but exclude menus, stun, and defeat."
          },
          "window-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The game's Fixed timing rule for this saved press, including its positive duration, unit, inclusive last moment, clock, pause behaviour, and open-state test."
          },
          "fires-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the first ordinary permission event that releases the saved action. A landing may release jump; recovery end may release dodge."
          },
          "cancels-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming every event that discards the saved press before it fires, or stating that no extra event does."
          },
          "waiting-press": {
            "type": "string",
            "required": true,
            "options": [
              "first-press-stays",
              "latest-press-replaces"
            ],
            "description": "Which matching press survives while this row already holds one: the first stays, or the latest replaces it. A menu confirm may keep the first click or replace it with the second."
          },
          "held-after-fire": {
            "type": "string",
            "required": true,
            "options": [
              "fresh-press-required",
              "hold-can-repeat"
            ],
            "description": "Whether an uninterrupted hold needs a release and fresh press or may prepare another action after this buffer fires. A racing boost may repeat from one hold."
          }
        }
      },
      "target-moment-windows": {
        "description": "Inputs accepted near a cited target moment, such as a rhythm beat or an incoming strike's impact.",
        "when-empty": "No input is forgiven because it falls near a target moment.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as lead-note-hit or sword-impact-parry."
          },
          "action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game action judged against the target moment, such as hit-note or parry. The reserved all-actions spelling covers the game's complete action set."
          },
          "action-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the action input, its ordinary permission, and its complete attempt. This target row grades an attempt; it does not grant permission. For the reserved all-actions spelling, it names these for every action in the set."
          },
          "target-moment-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the target moment."
          },
          "arms-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the event that creates the current target instance and which input events are associated with it."
          },
          "window-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The game's one Fixed timing rule for the outer target-relative window, including its early and late bounds of positive width, inclusive last moments, unit, clock, pause behaviour, and open-state test."
          },
          "result-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed result rule for an accepted input. It owns any grade boundaries inside this row's one outer window and states any departure from first-accepted settlement; a rhythm note may record perfect, great, or good."
          },
          "cancels-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming every event that stops this target instance from accepting input before the cited window closes, or stating that no extra event does."
          }
        }
      },
      "competition-rules": {
        "description": "Situations where several forgiven inputs are ready together and one fixed game priority selects a single attempt. Rows exist only under the declared-priority answer; an adoption answering otherwise, or answering nothing, has none.",
        "when-empty": "No competition priority rule is declared.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as recovery-end-actions."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule identifying the situation and giving one total priority over every forgiven input that can be ready there."
          }
        }
      }
    }
  },
  "rules": {},
  "origin": "https://opengdd.org/contracts/input-forgiveness-1",
  "mechanism": [
    "This is the single normative authority for when forgiveness arms, what input it captures or accepts, how repeated and competing inputs settle, when an action fires, and what clears the forgiveness state. Questions and rows describe the game's choices and cite its rules; they do not define another sequence.",
    "An action or input not matched by a row in the current situation receives no forgiveness from this adoption, and no cited game rule outside these rows promises it any.",
    "An **action input** is the game-facing input event supplied after Control options maps a physical control. **Ordinary permission** is the action's legal state before any forgiveness. A **ready forgiven input** is either an input accepted for immediate submission by a late or target row, or a saved buffered press whose cited firing event has arrived. A **target moment** is the cited beat, impact, cue, or comparable game instant against which input timing is judged. A target instance is **settled** when it may accept no further input; the first accepted input settles it unless the cited result rule says otherwise. A **press** is the arrival of the action input, whichever physical edge the cited action rule uses — a release-triggered action counts. For every family, when §4's agreeing Timed window adoption exists for a cited window, runtime openness reads from it; otherwise the cited Fixed timing rule decides.",
    "### Arm forgiveness windows",
    "1. Arming runs on game events, not on input receipt. Whenever a row's cited arming event occurs, it creates one window instance under the cited Fixed timing rule: a late event creates one instance for that loss of permission, and a target event creates one per-target instance, in both cases before and independently of any input. A buffer's per-press instance is the exception: the qualifying press itself creates it at the moment step 6 stores the press. This contract owns those instance scopes.",
    "### Receive an action input",
    "2. Map the physical control to its game action through Control options. Read the action's ordinary permission and every matching row for the current situation. Physical device identity does not change a row's settlement. By default, a control already held when a late or target row arms creates no action input; the cited action rule may explicitly define a different input. 3. Ordinary permission gates only late-input and buffer evaluation. When the action is ordinarily permitted, do not evaluate those two families. Do not submit yet: the target branch in step 4 runs whether ordinary permission is present or absent. 4. Evaluate every matching target row for its associated target instance, regardless of ordinary permission. An open row can grade only an otherwise-legal attempt; it never grants ordinary permission. The accepted input becomes ready now, and the first accepted input settles the target unless that result rule says otherwise. Two rows of one family matching one input in the same situation are an invalid adoption rather than an implicit choice. 5. If a target row accepted this input, end this receipt. If no target row accepts and ordinary permission exists, submit the ordinary attempt without forgiveness and end this receipt. Otherwise — ordinary permission is absent — a matching late row may accept after its cited arming event while its window is open. An accepted late input becomes ready now. 6. If neither immediate family accepts, a matching input-buffer row may save the press only while its cited arming rule holds. Storing the press creates its per-press window instance. The row stores at most one press, its action, input moment, and that instance. For a row whose action is the reserved `all-actions` spelling, a press of any covered action is a matching press of that row. If one already waits, apply that row's `waiting-press` field: `first-press-stays` ignores the later press, while `latest-press-replaces` clears the earlier press and creates a fresh instance for the later one.",
    "### Advance, fire, and clear rows",
    "7. A live late-input row ends when its action executes, ordinary permission returns, the cited timing window closes, or its cited early-clearing event occurs. Action execution cannot arm a replacement late window. 8. A waiting buffer clears without firing when its cited timing window closes or its cited early-clearing event occurs. If neither happens, the first cited ordinary permission event makes it ready. No later input poll or extra delay is inserted. 9. A target-moment row accepts no further input for a target instance after the cited timing window closes, the target is settled, or its cited early-clearing event occurs. Whether the window was open at the input moment follows the openness rule in this section's definitions. 10. Collect every ready forgiven input at this game moment. A ready input exists once; a repeated update cannot create another copy from the same stored press or accepted input. When two adoptions of this contract produce ready inputs at one moment, settle each adoption independently, then submit all inputs selected by either adoption together.",
    "### Settle competition and submit attempts",
    "11. Under `all-ready-actions`, submit every ready forgiven input once. Under `declared-priority`, find the one matching competition row and submit only its highest-priority input; every situation in which forgiven inputs can be ready together has exactly one such row; the cited priority holds stable for the whole settlement moment. Clear every lower-priority ready input without submitting it. Under `cannot-coincide`, two ready inputs invalidate the design claim. 12. Submit selected inputs as action proposals at this moment. Event resolution owns the order of proposals that share the moment. The action's Fixed rules own cost, effect, and any rejection after submission. Forgiveness does not force an otherwise conflicting action to succeed. 13. Clear each submitted or competition-losing buffered press immediately. Clear a submitted late window. A competition-losing late window survives until its own close or clearing event; while it remains open it may accept a new press, and the cleared input is not restored. A losing target instance stays open until settled or closed; under the default first-accepted rule it is already settled. A target input has no saved press after submission. 14. Apply the firing buffer row's `held-after-fire` field only after its action fires and its saved press has been cleared. Under `fresh-press-required`, held state creates nothing until release and a fresh press. Under `hold-can-repeat`, the uninterrupted hold creates one new press when that row's arming condition next holds. If its cited window later closes while the hold and arming condition still hold, clear it and create one fresh waiting press immediately. At most one waits in the row. 15. A rejected action proposal does not restore its cleared forgiveness state. A new attempt needs a new qualifying arming event or press. Event resolution owns the consequences of the rejection; this contract owns only the cleared forgiveness state.",
    "The authority order is therefore: arming, physical input mapping, ordinary permission, target acceptance, late acceptance, buffer capture, repeated-press choice, cited open-window and early-clearing state, firing event, competition selection, same-moment event order, action rules, clearing, and held-input renewal. A later stage never rewrites an earlier input moment or target moment."
  ],
  "answers": {
    "ready-together": "cannot-coincide"
  },
  "values": {},
  "rows": {
    "late-input-windows": [],
    "input-buffers": [],
    "target-moment-windows": [
      {
        "id": "lead-note-hit",
        "action": "hit-note",
        "action-declared-in": "rhythm.hit-note-action",
        "target-moment-declared-in": "rhythm.lead-note-target-beat",
        "arms-when-declared-in": "rhythm.lead-note-input-association",
        "window-declared-in": "rhythm.lead-note-two-sided-hit-window",
        "result-declared-in": "rhythm.lead-note-timing-grade",
        "cancels-when-declared-in": "rhythm.lead-note-cancellation"
      }
    ],
    "competition-rules": []
  },
  "pack": "sha256:dc06d707164dbb72befb35426803f2adc6e4bedee5496e3a30a9c8a9c2491120"
}