RTS select order and cast

rts-select-order-and-cast · an adoption of Pointer command, 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.

Open in the authoring tool Download ZIP

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/.

Download adoption JSON · Download tests

The contract behind it

Covers pointer gestures that select things in the world and issue commands to or at the world. It records direct world orders, chosen abilities and verbs, added orders, and cancellation. Physical bindings, camera view, readouts, pathfinding, unit AI, and formations stay elsewhere.

Read the full Pointer command 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.

Show exact wording for builders

Who receives a command made by pointing at the world?

Fixed actor	One fixed actor or party receives every world command. An ARPG hero moves wherever the ground is clicked. Every proposed command names the actor or party fixed by its cited command rule. No world selection is required to supply a receiver.
Current selectionSupplied answer	The current world selection receives every command. An RTS order moves the selected squad. The receiver set is the complete current selection. An empty set is a rejected receiver.
World target	The command belongs to the pointed place or object, without a selected actor. A colony work order marks one ore tile for any worker. A proposed command names its world target and no selected receiver. The cited game rule owns any later choice of actor, worker, structure, or world system that carries it out.

Why this is asked

A pointer command may control one standing actor, the current selection, or the pointed place itself.

When the pointer just misses a target, what can it choose?

Exact point onlySupplied answer	Only the exact pointed place or object counts. A click beside a chest does not choose it. Candidate lookup uses the exact pointer point and applies no near-miss reach.
Nearest within reach	The nearest candidate inside the game's declared reach counts. A click beside a small lever can choose it. Candidate lookup chooses the nearest selectable candidate inside the cited reach and uses the cited complete tie-break.

Why this is asked

The game can require the exact point or choose the nearest candidate inside a declared reach.

The player clicks or drags to choose units and finds nothing there. What happens to the earlier choice?

Asked when: the selection gestures list has at least one row.
If not asked: No pointer gesture changes the current world selection.

Clear selectionSupplied answer	The current selection is cleared. A tactics click on open ground leaves no unit selected. The declared empty-result consequence is an empty selection.
Keep selection	The current selection stays. A colony drag across bare ground leaves the chosen workers selected. The declared empty-result consequence preserves the earlier selection.

Why this is asked

An empty click or box can clear the selection or leave the earlier choice in place. The answer binds only through replace rows; with none, it is inert.

Does the game keep waiting for a place to use the chosen ability or verb?

Asked when: the targeted verbs list has at least one row.
If not asked: No chosen ability or verb waits for a world target from the pointer.

Keep targetingSupplied answer	The game keeps waiting for another point. An ARPG fire spell still waits after the pointer lands outside its range. The invalid-target consequence keeps the same chosen verb active.
Leave targeting	The game stops waiting after the invalid point. A tower placement returns to ordinary pointing after a blocked tile. The invalid-target consequence clears the chosen verb.

Why this is asked

The next point can retry the choice, or the game can return to ordinary pointing.

The player holds the key that adds orders to a line. Where does the added order go?

Asked when: the queue modifiers list has at least one row.
If not asked: No pointer modifier adds a command to a waiting plan.

Append at endSupplied answer	The command joins the end of the waiting plan. An RTS shift-order adds a final waypoint. The declared placement is after every waiting command for the same plan owner.
Insert next	The command becomes next after the current command. A colony emergency repair runs before work already waiting. The declared placement is before every waiting command for the same plan owner.

Why this is asked

The command may wait behind the full plan or become the next command after the current one.

A new order arrives while another order is waiting. What happens without the add-orders key?

Asked when: the context commands list has at least one row, or the targeted verbs list has at least one row.
If not asked: No pointer command can enter a waiting plan.

Replaces waitingSupplied answer	The new order replaces every waiting pointer order for that owner. A hero turns toward the newest clicked destination. The unmodified placement clears waiting pointer commands for the same plan owner.
Always appends	The new order joins the end of that owner's waiting line. A colony keeps each new work mark. The unmodified placement is after every waiting pointer command for the same plan owner.
Rejected while busy	The new order is refused while that owner has work waiting. A build tool accepts no second placement until the first clears. An unmodified proposal is rejected while its plan owner has a waiting pointer command.

Why this is asked

A plain order can replace the waiting line, join it, or be refused while that owner is busy.

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.

Lists5 lists

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

Selection gestures

selection-gestures

Id	Gesture	Resolves on	Shape	Change	Gesture declared in	Candidates declared in
`point-select`	`select-point`	`release`	`point`	`replace`	`controls.select-point`	`units.point-selection`
`box-select`	`select-area`	`drag-complete`	`area`	`replace`	`controls.selection-drag`	`units.area-selection`
`add-unit-on-press`	`add-point-selection`	`press`	`point`	`add`	`controls.add-point-selection`	`units.point-selection`
`toggle-unit`	`toggle-point-selection`	`release`	`point`	`toggle`	`controls.toggle-point-selection`	`units.point-selection`

Context commands

context-commands

Id	Gesture	Resolves on	Target kind	Command	Gesture declared in	Target declared in	Area declared in	Receiver condition	Command declared in
`move-squad-on-ground`	`context-order`	`release`	`ground`	`move-squad`	`controls.context-order`	`battlefield.pointer-target-kinds`	—	—	`orders.move-squad`
`attack-enemy-squad`	`context-order`	`release`	`enemy`	`attack-target`	`controls.context-order`	`battlefield.pointer-target-kinds`	—	—	`orders.attack-target`
`harvest-with-workers`	`context-order`	`release`	`resource`	`harvest`	`controls.context-order`	`battlefield.pointer-target-kinds`	—	`units.worker-class`	`orders.harvest-resource`

Targeted verbs

targeted-verbs

Id	Verb	Order	Confirm style	Target gesture	Confirm gesture	Resolves on	After dispatch	Starts when declared in	Target gesture declared in	Confirm gesture declared in	Targets declared in	Area declared in	Command declared in
`artillery-target`	`artillery-barrage`	`verb-first`	`separate-gesture`	—	`confirm-world-target`	`release`	`leave-targeting`	`abilities.choose-artillery-barrage`	—	`controls.confirm-world-target`	`abilities.artillery-valid-ground`	—	`abilities.artillery-barrage-command`
`blink-smart-cast`	`blink`	`verb-first`	`at-entry-position`	—	—	`press`	`leave-targeting`	`abilities.choose-blink-smart-cast`	—	—	`abilities.blink-valid-ground`	—	`abilities.blink-command`

Queue modifiers

queue-modifiers

Id	Modifier action	Modifier declared in	Applies to declared in
`queue-orders`	`queue-command`	`controls.queue-command-active`	`orders.queueable-pointer-commands`

Cancellations

cancellations

Id	Action	Resolves on	Active state	Result	Action declared in	State declared in
`cancel-ability-target`	`context-order`	`release`	`targeting`	`ends-targeting`	`controls.context-order`	`abilities.pointer-targeting-state`
`abort-box-select`	`select-area`	`drag-cancel`	`selection-drag`	`ends-drag`	`controls.selection-drag`	`units.selection-drag-state`

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 tests85 tests apply

The contract comes with 64 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.

pointer-command-vocabulary

pointer command uses actions, phases, snapshots, and states

scenarioonce

Applies to rts-select-order-and-cast.

A game-facing pointer action arrives after physical input mapping. Its pointer phase is a press, release, completed drag, or cancelled drag, and its pointer snapshot is the world point and classified object at that phase. A cited non-pointer action has one completion phase. A selection drag and a targeting state begin and end only as the contract states. Device identity, several simultaneous pointers, and camera view or follow behavior assert nothing here.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and its cited pointer, action, selection, and command rules
When: the contract's state and records are identified before a pointer phase is resolved
Then: a game-facing pointer action is received after physical input mapping and a pointer phase is its press, release, completed drag, or cancelled drag
a pointer snapshot is the world point and classified object under the pointer at that phase
a cited non-pointer action that supplies a verb, confirmation, or cancellation has one completion phase, recorded as press unless its cited rule names release
a selection drag begins when its cited gesture rule crosses the drag threshold and ends when that action completes or cancels
a targeting state holds one chosen verb or one target-first snapshot waiting for the verb
device identity, several simultaneous pointers, and camera view or follow behavior are outside this contract and assert nothing here
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-targeting-state

selection-proposal-and-plan-vocabulary

selection, proposals, and waiting plans keep distinct meanings

scenarioonce

Applies to rts-select-order-and-cast.

The current selection is one set and starts empty unless a cited load or scene-entry rule supplies it. It persists until a cited rule changes it. A command proposal contains one command, receiver shape, exact world target, and queue placement. A waiting plan contains pointer commands accepted for later execution for its cited plan owner.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption with distinguishable selection, proposal, and waiting-plan records
When: a selection change and a pointer command are each followed through their declared route
Then: the current selection is one set of world objects and begins empty unless a cited load or scene-entry rule supplies it
the selection persists until a cited pointer, control-group recall, death, roster, scene-entry, or load rule changes it
one command proposal contains one command, its receiver shape, its exact world target, and its queue placement
one waiting plan contains pointer commands accepted for later execution for the plan owner named by the cited command rule
Diagnostics: rts-select-order-and-cast-selection-state
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-plan-state

selection-gesture-resolves-at-declared-phase · point-select

selection gesture `point-select` resolves at its declared phase

scenarioper selection-gestures row

Applies to the point-select row.

Selection row point-select matches action select-point and resolves from the final snapshot at release under controls.select-point. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row point-select and the gesture rule at controls.select-point
When: game-facing pointer action select-point is performed through its declared press, movement, and release
Then: point-select resolves from the final snapshot at release
the row matches only its declared game-facing pointer action and resolving phase
the test leaves recognition, thresholds, and geometry to controls.select-point and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log

selection-gesture-resolves-at-declared-phase · box-select

selection gesture `box-select` resolves at its declared phase

scenarioper selection-gestures row

Applies to the box-select row.

Selection row box-select matches action select-area and resolves once when the recognized drag completes; an aborted drag creates one drag-cancel phase belonging to select-area and no completed result under controls.selection-drag. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row box-select and the gesture rule at controls.selection-drag
When: game-facing pointer action select-area is performed through its declared press, movement, and release
Then: box-select resolves once when the recognized drag completes; an aborted drag creates one drag-cancel phase belonging to select-area and no completed result
the row matches only its declared game-facing pointer action and resolving phase
the test leaves recognition, thresholds, and geometry to controls.selection-drag and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log

selection-gesture-resolves-at-declared-phase · add-unit-on-press

selection gesture `add-unit-on-press` resolves at its declared phase

scenarioper selection-gestures row

Applies to the add-unit-on-press row.

Selection row add-unit-on-press matches action add-point-selection and resolves immediately from the press snapshot; a later drag or release is not inferred from that press under controls.add-point-selection. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row add-unit-on-press and the gesture rule at controls.add-point-selection
When: game-facing pointer action add-point-selection is performed through its declared press, movement, and release
Then: add-unit-on-press resolves immediately from the press snapshot; a later drag or release is not inferred from that press
the row matches only its declared game-facing pointer action and resolving phase
the test leaves recognition, thresholds, and geometry to controls.add-point-selection and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log

selection-gesture-resolves-at-declared-phase · toggle-unit

selection gesture `toggle-unit` resolves at its declared phase

scenarioper selection-gestures row

Applies to the toggle-unit row.

Selection row toggle-unit matches action toggle-point-selection and resolves from the final snapshot at release under controls.toggle-point-selection. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row toggle-unit and the gesture rule at controls.toggle-point-selection
When: game-facing pointer action toggle-point-selection is performed through its declared press, movement, and release
Then: toggle-unit resolves from the final snapshot at release
the row matches only its declared game-facing pointer action and resolving phase
the test leaves recognition, thresholds, and geometry to controls.toggle-point-selection and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log

context-gesture-resolves-at-declared-phase · move-squad-on-ground

context command `move-squad-on-ground` resolves at its declared phase

scenarioper context-commands row

Applies to the move-squad-on-ground row.

Context row move-squad-on-ground matches action context-order and resolves from the final snapshot at release under controls.context-order. Where that cited rule emits repeated completed phases while held, each emitted phase produces exactly one move-squad proposal; where it emits none, this clause asserts nothing. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: context row move-squad-on-ground and the gesture rule at controls.context-order
When: game-facing pointer action context-order is performed through its declared press, movement, and release
Then: move-squad-on-ground resolves from the final snapshot at release
the row matches only its declared game-facing pointer action and resolving phase
where controls.context-order emits repeated completed phases while held, each emitted phase produces exactly one move-squad proposal; where it emits none, this clause asserts nothing
the test leaves recognition, thresholds, and geometry to controls.context-order and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log

context-gesture-resolves-at-declared-phase · attack-enemy-squad

context command `attack-enemy-squad` resolves at its declared phase

scenarioper context-commands row

Applies to the attack-enemy-squad row.

Context row attack-enemy-squad matches action context-order and resolves from the final snapshot at release under controls.context-order. Where that cited rule emits repeated completed phases while held, each emitted phase produces exactly one attack-target proposal; where it emits none, this clause asserts nothing. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: context row attack-enemy-squad and the gesture rule at controls.context-order
When: game-facing pointer action context-order is performed through its declared press, movement, and release
Then: attack-enemy-squad resolves from the final snapshot at release
the row matches only its declared game-facing pointer action and resolving phase
where controls.context-order emits repeated completed phases while held, each emitted phase produces exactly one attack-target proposal; where it emits none, this clause asserts nothing
the test leaves recognition, thresholds, and geometry to controls.context-order and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log

context-gesture-resolves-at-declared-phase · harvest-with-workers

context command `harvest-with-workers` resolves at its declared phase

scenarioper context-commands row

Applies to the harvest-with-workers row.

Context row harvest-with-workers matches action context-order and resolves from the final snapshot at release under controls.context-order. Where that cited rule emits repeated completed phases while held, each emitted phase produces exactly one harvest proposal; where it emits none, this clause asserts nothing. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: context row harvest-with-workers and the gesture rule at controls.context-order
When: game-facing pointer action context-order is performed through its declared press, movement, and release
Then: harvest-with-workers resolves from the final snapshot at release
the row matches only its declared game-facing pointer action and resolving phase
where controls.context-order emits repeated completed phases while held, each emitted phase produces exactly one harvest proposal; where it emits none, this clause asserts nothing
the test leaves recognition, thresholds, and geometry to controls.context-order and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log

targeted-verb-resolves-at-declared-phase · artillery-target

targeted verb `artillery-target` resolves at its declared phase

scenarioper targeted-verbs row

Applies to the artillery-target row.

Targeted verb artillery-target uses the final pointer snapshot at its declared release completion. One completed phase is recorded before validity is tested, and an incomplete phase creates no command proposal.

Test steps and diagnostics

Given: targeted-verb row artillery-target in its declared targeting route
When: its capture or confirmation reaches release
Then: artillery-target uses the final pointer snapshot at its declared release completion
one completed phase is recorded before validity is tested
an incomplete phase creates no command proposal
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log

targeted-verb-resolves-at-declared-phase · blink-smart-cast

targeted verb `blink-smart-cast` resolves at its declared phase

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

Targeted verb blink-smart-cast uses the pointer snapshot at its declared press completion. One completed phase is recorded before validity is tested, and an incomplete phase creates no command proposal.

Test steps and diagnostics

Given: targeted-verb row blink-smart-cast in its declared targeting route
When: its capture or confirmation reaches press
Then: blink-smart-cast uses the pointer snapshot at its declared press completion
one completed phase is recorded before validity is tested
an incomplete phase creates no command proposal
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log

gesture-rule-alone-classifies-motion

the cited gesture rule alone classifies motion

scenarioonce

Applies to rts-select-order-and-cast.

The cited gesture rule alone decides whether movement stays a point gesture, becomes a drag, or cancels. Its distance, duration, geometry, coordinate space, and boundary rule are read directly; this adoption contributes no number.

Test steps and diagnostics

Given: each pointer action the rts-select-order-and-cast adoption can perform, including positions on either side of every cited gesture boundary
When: the action moves and ends
Then: the cited gesture rule alone decides point, drag, or cancel
the result follows the cited distance, duration, geometry, coordinate space, and boundary rule
the adoption contributes no gesture quantity of its own
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log

one-physical-sequence-one-result

one physical sequence produces one pointer result

scenarioonce

Applies to rts-select-order-and-cast.

One physical sequence produces a point result or a drag result, never both. If the cited rule creates two distinct game-facing pointer actions, each has its own result; otherwise that exception asserts nothing.

Test steps and diagnostics

Given: each physical pointer sequence the rts-select-order-and-cast adoption can recognize
When: the sequence passes through press, movement, and release
Then: the sequence produces a point result or a drag result, never both
where the cited gesture rule creates two distinct game-facing pointer actions, each action has its own result; otherwise that exception asserts nothing
Diagnostics: rts-select-order-and-cast-pointer-result

repeated-completed-phases-stay-distinct

each repeated completed command phase produces one proposal

scenarioonce

Applies to rts-select-order-and-cast.

Where a cited gesture rule emits repeated completed command phases while held, each phase has its own result and produces exactly one proposal. A held interval with no repeated phase produces no extra proposal. Where no rule emits repeated phases, this test asserts nothing.

Test steps and diagnostics

Given: a held control whose cited gesture rule emits repeated completed command phases, where the adoption has one
When: the control remains held through two cited completed phases
Then: each emitted completed phase has its own pointer result
each completed command phase produces exactly one command proposal
a held interval that emits no repeated completed phase produces no extra proposal
where no cited rule emits repeated completed phases, this test asserts nothing
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-proposal-log

cancellation-applies-before-other-rows · cancel-ability-target

cancellation `cancel-ability-target` applies before any other row

scenarioper cancellations row

Applies to the cancel-ability-target row.

Cancellation cancel-ability-target matches action context-order, its release phase, and the holding state in abilities.pointer-targeting-state before any other row. It ends the targeting state, proposes no command, changes no selection beyond empties-selection, and ends the phase. Where more than one cancellation row could match, the contract checks the holding state in the order targeting, selection-drag, queued-commands, selection. A mismatch does not apply this row and asserts nothing about another cancellation. Area cancellation asserts nothing here.

Test steps and diagnostics

Given: cancellation row cancel-ability-target, action context-order, and the cited state at abilities.pointer-targeting-state
When: a targeting state is active and context-order reaches release
the nearest action, phase, or holding-state mismatch is also checked
Then: the complete match is checked before selection, context-command, or targeting rows and ends the targeting state
the matched phase proposes no command, changes no selection beyond empties-selection, and ends immediately
where more than one cancellation row could match, the holding state is checked in the order targeting, selection-drag, queued-commands, selection
the mismatch does not apply cancel-ability-target and asserts nothing about another matching cancellation row
an area cancellation, if the game has one, asserts nothing here because this row has no dragged cancellation region
Diagnostics: rts-select-order-and-cast-cancellation-log
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-selection-state
rts-select-order-and-cast-plan-state
rts-select-order-and-cast-proposal-log

cancellation-applies-before-other-rows · abort-box-select

cancellation `abort-box-select` applies before any other row

scenarioper cancellations row

Applies to the abort-box-select row.

Cancellation abort-box-select matches action select-area, its drag-cancel phase, and the holding state in units.selection-drag-state before any other row. It ends the selection drag, proposes no command, changes no selection beyond empties-selection, and ends the phase. Where more than one cancellation row could match, the contract checks the holding state in the order targeting, selection-drag, queued-commands, selection. A mismatch does not apply this row and asserts nothing about another cancellation. Area cancellation asserts nothing here.

Test steps and diagnostics

Given: cancellation row abort-box-select, action select-area, and the cited state at units.selection-drag-state
When: a selection drag is active and select-area reaches drag-cancel
the nearest action, phase, or holding-state mismatch is also checked
Then: the complete match is checked before selection, context-command, or targeting rows and ends the selection drag
the matched phase proposes no command, changes no selection beyond empties-selection, and ends immediately
where more than one cancellation row could match, the holding state is checked in the order targeting, selection-drag, queued-commands, selection
the mismatch does not apply abort-box-select and asserts nothing about another matching cancellation row
an area cancellation, if the game has one, asserts nothing here because this row has no dragged cancellation region
Diagnostics: rts-select-order-and-cast-cancellation-log
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-selection-state
rts-select-order-and-cast-plan-state
rts-select-order-and-cast-proposal-log

verb-first-begins-targeting · artillery-target

verb-first row `artillery-target` begins from its cited action

scenarioper targeted-verbs row

Applies to the artillery-target row.

For verb-first row artillery-target, the action at abilities.choose-artillery-barrage supplies artillery-barrage and begins targeting. A second entry does not replace an active state unless that cited rule explicitly does so. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: targeted-verb row artillery-target with no active targeting state and the start rule at abilities.choose-artillery-barrage
When: the cited game action supplies verb artillery-barrage
the same entry is attempted while a targeting state is already active
Then: the first action begins a targeting entry holding artillery-barrage
the second entry does not replace the active state unless abilities.choose-artillery-barrage explicitly replaces it
the test leaves the start action and any explicit replacement to abilities.choose-artillery-barrage and restates nothing from it
Diagnostics: rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-snapshot-log

verb-first-begins-targeting · blink-smart-cast

verb-first row `blink-smart-cast` begins from its cited action

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

For verb-first row blink-smart-cast, the action at abilities.choose-blink-smart-cast supplies blink and begins targeting. A second entry does not replace an active state unless that cited rule explicitly does so. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: targeted-verb row blink-smart-cast with no active targeting state and the start rule at abilities.choose-blink-smart-cast
When: the cited game action supplies verb blink
the same entry is attempted while a targeting state is already active
Then: the first action begins a targeting entry holding blink
the second entry does not replace the active state unless abilities.choose-blink-smart-cast explicitly replaces it
the test leaves the start action and any explicit replacement to abilities.choose-blink-smart-cast and restates nothing from it
Diagnostics: rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-snapshot-log

target-first-captures-before-verb

target-first row `Row.id` captures its target before the verb

scenarioper targeted-verbs row

Does not apply to rts-select-order-and-cast: no row in targeted-verbs matches order target first.

separate-confirmation-reads-completion-snapshot · artillery-target

`artillery-target` reads the target when confirmation completes

scenarioper targeted-verbs row

Applies to the artillery-target row.

For artillery-target, separate confirmation confirm-world-target reads the pointer snapshot at confirmation completion. A non-pointer confirmation that reads a pointer snapshot uses the pointer position at that action's completion; where this row reads a dragged region, that clause asserts nothing. Recognition comes from controls.confirm-world-target; the test names the address and restates nothing from it.

Test steps and diagnostics

Given: active targeting for artillery-target and confirmation action confirm-world-target recognized at controls.confirm-world-target
When: the confirmation completes at release after the pointer has moved from the entry position
Then: confirmation reads the pointer snapshot at confirmation completion
for a non-pointer confirmation that reads a pointer snapshot, the snapshot uses the pointer position at that action's completion; where this row reads a dragged region, this clause asserts nothing
the test leaves recognition and completion to controls.confirm-world-target and restates nothing from it
Diagnostics: rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-pointer-result

entry-position-confirmation-keeps-entry-snapshot · blink-smart-cast

`blink-smart-cast` confirms from its entry snapshot

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

At-entry-position row blink-smart-cast confirms from the pointer position captured when the verb-first entry begins. A later pointer position does not replace that snapshot.

Test steps and diagnostics

Given: targeted-verb row blink-smart-cast with distinguishable entry and later pointer snapshots
When: the row captures its declared entry-time snapshot and the pointer later occupies another position
Then: confirmation reads the pointer position captured when the verb-first entry begins
the later pointer position does not replace that snapshot
Diagnostics: rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-targeting-state

targeted-drag-uses-cited-region

dragged verb `Row.id` uses its cited region

scenarioper targeted-verbs row

Does not apply to rts-select-order-and-cast: no row in targeted-verbs matches resolves-on drag complete.

targeted-verb-tests-candidate-and-validity · artillery-target

`artillery-target` resolves a candidate and tests validity

scenarioper targeted-verbs row

Applies to the artillery-target row.

Targeted verb artillery-target applies near-miss resolution and validity through abilities.artillery-valid-ground. The result record distinguishes a valid target from an invalid one. The test names the address and restates nothing from it. Verbs needing several separately confirmed points assert nothing here.

Test steps and diagnostics

Given: targeted-verb row artillery-target with one cited valid target and one cited invalid target under abilities.artillery-valid-ground
When: each target reaches the row's confirmation route
Then: candidate lookup applies the adoption's near-miss-resolution answer through abilities.artillery-valid-ground
the cited validity test records valid for the valid target and invalid for the invalid target
the test leaves target kinds, reach, tie-break, and validity content to abilities.artillery-valid-ground and restates nothing from it
a verb needing several separately confirmed points asserts nothing here
Diagnostics: rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-targeting-state

targeted-verb-tests-candidate-and-validity · blink-smart-cast

`blink-smart-cast` resolves a candidate and tests validity

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

Targeted verb blink-smart-cast applies near-miss resolution and validity through abilities.blink-valid-ground. The result record distinguishes a valid target from an invalid one. The test names the address and restates nothing from it. Verbs needing several separately confirmed points assert nothing here.

Test steps and diagnostics

Given: targeted-verb row blink-smart-cast with one cited valid target and one cited invalid target under abilities.blink-valid-ground
When: each target reaches the row's confirmation route
Then: candidate lookup applies the adoption's near-miss-resolution answer through abilities.blink-valid-ground
the cited validity test records valid for the valid target and invalid for the invalid target
the test leaves target kinds, reach, tie-break, and validity content to abilities.blink-valid-ground and restates nothing from it
a verb needing several separately confirmed points asserts nothing here
Diagnostics: rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-targeting-state

invalid-target-keeps-targeting

an invalid target keeps targeting

scenarioonce

Applies to rts-select-order-and-cast.

An invalid target creates no command proposal, keeps the same chosen verb active, and never falls through to a context command from the same phase. The result records invalid target rather than a rejected proposal.

Test steps and diagnostics

Given: each targeted verb in rts-select-order-and-cast with an invalid target under its cited target rule
When: the verb reaches confirmation and the target fails validity
Then: no command proposal is created
the same chosen verb remains active for another target
no context-command row runs from the same phase
the pointer result records invalid target rather than a rejected proposal
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-proposal-log

invalid-target-leaves-targeting

an invalid target leaves targeting

scenarioonce

Does not apply to rts-select-order-and-cast: invalid target is keep targeting, not leave targeting.

valid-target-creates-one-proposal · artillery-target

a valid target creates one `artillery-target` proposal

scenarioper targeted-verbs row

Applies to the artillery-target row.

A valid target for artillery-target creates one proposal carrying the exact target, the command from abilities.artillery-barrage-command, and the receiver selected by the command-receiver answer. It ends targeting after the proposal is dispatched, placed, or rejected. Rejection remains a dispatched proposal and does not restore the earlier targeting instance. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: targeted-verb row artillery-target with a valid resolved target under abilities.artillery-valid-ground
When: the row completes confirmation and its proposal reaches placement
Then: one command proposal is created with the command from abilities.artillery-barrage-command, the receiver selected by the command-receiver answer, the validated exact target, and a placement outcome
the proposal preserves the row result that ends targeting after the proposal is dispatched, placed, or rejected
rejection remains a dispatched proposal and does not restore the earlier targeting instance
the test leaves permission, cost, range, path, unreachable result, effect, and rejection to abilities.artillery-barrage-command and restates nothing from it
Diagnostics: rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-plan-state

valid-target-creates-one-proposal · blink-smart-cast

a valid target creates one `blink-smart-cast` proposal

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

A valid target for blink-smart-cast creates one proposal carrying the exact target, the command from abilities.blink-command, and the receiver selected by the command-receiver answer. It ends targeting after the proposal is dispatched, placed, or rejected. Rejection remains a dispatched proposal and does not restore the earlier targeting instance. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: targeted-verb row blink-smart-cast with a valid resolved target under abilities.blink-valid-ground
When: the row completes confirmation and its proposal reaches placement
Then: one command proposal is created with the command from abilities.blink-command, the receiver selected by the command-receiver answer, the validated exact target, and a placement outcome
the proposal preserves the row result that ends targeting after the proposal is dispatched, placed, or rejected
rejection remains a dispatched proposal and does not restore the earlier targeting instance
the test leaves permission, cost, range, path, unreachable result, effect, and rejection to abilities.blink-command and restates nothing from it
Diagnostics: rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-plan-state

targeting-suppresses-selection-and-context · artillery-target

`artillery-target` targeting suppresses ordinary selection and context rows

scenarioper targeted-verbs row

Applies to the artillery-target row.

While the targeting state for artillery-target is active, an ordinary selection or context gesture has no meaning. If the same action and phase matches a cancellation row in the holding state, only the cancellation applies. A branch the adoption cannot construct asserts nothing.

Test steps and diagnostics

Given: targeted-verb row artillery-target's active targeting state and a game-facing pointer action that would match a selection or context row with no targeting state
When: the action completes while targeting is active, first without and then with a matching cancellation row where one exists
Then: without a matching cancellation row, the action changes no selection and creates no context-command proposal
with a matching cancellation row, only that cancellation result applies and the phase ends
where either branch cannot be constructed, that branch asserts nothing
Diagnostics: rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-selection-state
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-cancellation-log

targeting-suppresses-selection-and-context · blink-smart-cast

`blink-smart-cast` targeting suppresses ordinary selection and context rows

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

While the targeting state for blink-smart-cast is active, an ordinary selection or context gesture has no meaning. If the same action and phase matches a cancellation row in the holding state, only the cancellation applies. A branch the adoption cannot construct asserts nothing.

Test steps and diagnostics

Given: targeted-verb row blink-smart-cast's active targeting state and a game-facing pointer action that would match a selection or context row with no targeting state
When: the action completes while targeting is active, first without and then with a matching cancellation row where one exists
Then: without a matching cancellation row, the action changes no selection and creates no context-command proposal
with a matching cancellation row, only that cancellation result applies and the phase ends
where either branch cannot be constructed, that branch asserts nothing
Diagnostics: rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-selection-state
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-cancellation-log

selection-or-context-row-match

one selection or context row matches without targeting

scenarioonce

Applies to rts-select-order-and-cast.

With no active targeting state, if a selection or context row matches action, phase, and classification, exactly one proceeds. A target-first capture gesture is resolved at targeting entry and is neither a selection or context row match nor an unmatched classification. If no row matches, no world-command state changes and the unmatched classification is recorded. Where no unmatched classification can be constructed, that branch asserts nothing.

Test steps and diagnostics

Given: no active targeting state and each classified pointer snapshot the rts-select-order-and-cast adoption can produce, including an unmatched classification where one can be constructed
When: the game-facing pointer action reaches a completed phase
Then: where a row matches, exactly one selection or context row proceeds from its action, phase, and classification
a target-first capture gesture is resolved at targeting entry and is neither a selection or context row match nor an unmatched classification
where no row matches, no world-command state changes and the result records the unmatched classification
where every constructible classification matches, the unmatched branch asserts nothing
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-selection-state
rts-select-order-and-cast-proposal-log

receiver-conditioned-context-match · harvest-with-workers

`harvest-with-workers` also matches its cited receiver class

scenarioper context-commands row

Applies to the harvest-with-workers row.

Context row harvest-with-workers also matches the receiver class at units.worker-class. Where another row cites a different receiver class for the same action, phase, and target kind, the selection holds one class at a time under that citation. The non-matching class matches no row here, changes no world-command state, and is recorded as an unmatched classification. Per-member dispatch for a mixed selection asserts nothing here. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: context row harvest-with-workers, the receiver classes distinguished at units.worker-class, and otherwise identical action, phase, and target classifications
When: the context action completes once with a matching receiver class and once with a non-matching class
Then: harvest-with-workers matches only the receiver class named at units.worker-class
where another row cites a different receiver class for the same action, phase, and target kind, the selection holds one class at a time under that citation
the non-matching class matches no row here, changes no world-command state, and is recorded as an unmatched classification
per-member dispatch asserts nothing here
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-selection-state
rts-select-order-and-cast-proposal-log

selection-row-uses-complete-candidate-set · point-select

selection row `point-select` commits its complete candidate set once

scenarioper selection-gestures row

Applies to the point-select row.

Selection row point-select reads the complete candidate set at the pointer point from units.point-selection and replaces the current selection with the complete non-empty set; for an empty set it follows the adoption's empty-selection answer; a non-empty result, or an empty replace result that changes the selection, is committed once; an unchanged empty result records no selection change. The phase ends without a proposal. Selection layers assert nothing here. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row point-select with a non-empty and an empty result from units.point-selection
When: select-point completes at release for each result
Then: candidate lookup returns the complete candidate set at the pointer point through units.point-selection
the row replaces the current selection with the complete non-empty set; for an empty set it follows the adoption's empty-selection answer; a non-empty result, or an empty replace result that changes the selection, is committed once; an unchanged empty result records no selection change
the pointer phase ends without a command proposal
the test leaves candidate kinds, inclusion, reach, and tie-break to units.point-selection and restates nothing from it
selection layers assert nothing here because the result is one set
Diagnostics: rts-select-order-and-cast-selection-state
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-proposal-log

selection-row-uses-complete-candidate-set · box-select

selection row `box-select` commits its complete candidate set once

scenarioper selection-gestures row

Applies to the box-select row.

Selection row box-select reads the complete candidate set inside the cited dragged area from units.area-selection and replaces the current selection with the complete non-empty set; for an empty set it follows the adoption's empty-selection answer; a non-empty result, or an empty replace result that changes the selection, is committed once; an unchanged empty result records no selection change. The phase ends without a proposal. Selection layers assert nothing here. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row box-select with a non-empty and an empty result from units.area-selection
When: select-area completes at drag-complete for each result
Then: candidate lookup returns the complete candidate set inside the cited dragged area through units.area-selection
the row replaces the current selection with the complete non-empty set; for an empty set it follows the adoption's empty-selection answer; a non-empty result, or an empty replace result that changes the selection, is committed once; an unchanged empty result records no selection change
the pointer phase ends without a command proposal
the test leaves candidate kinds, inclusion, reach, and tie-break to units.area-selection and restates nothing from it
selection layers assert nothing here because the result is one set
Diagnostics: rts-select-order-and-cast-selection-state
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-proposal-log

selection-row-uses-complete-candidate-set · add-unit-on-press

selection row `add-unit-on-press` commits its complete candidate set once

scenarioper selection-gestures row

Applies to the add-unit-on-press row.

Selection row add-unit-on-press reads the complete candidate set at the pointer point from units.point-selection and adds the complete non-empty set; an empty set keeps the current selection; a non-empty result is committed once and an unchanged empty result records no selection change. The phase ends without a proposal. Selection layers assert nothing here. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row add-unit-on-press with a non-empty and an empty result from units.point-selection
When: add-point-selection completes at press for each result
Then: candidate lookup returns the complete candidate set at the pointer point through units.point-selection
the row adds the complete non-empty set; an empty set keeps the current selection; a non-empty result is committed once and an unchanged empty result records no selection change
the pointer phase ends without a command proposal
the test leaves candidate kinds, inclusion, reach, and tie-break to units.point-selection and restates nothing from it
selection layers assert nothing here because the result is one set
Diagnostics: rts-select-order-and-cast-selection-state
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-proposal-log

selection-row-uses-complete-candidate-set · toggle-unit

selection row `toggle-unit` commits its complete candidate set once

scenarioper selection-gestures row

Applies to the toggle-unit row.

Selection row toggle-unit reads the complete candidate set at the pointer point from units.point-selection and toggles every member of the complete non-empty set; an empty set keeps the current selection; a non-empty result is committed once and an unchanged empty result records no selection change. The phase ends without a proposal. Selection layers assert nothing here. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: selection row toggle-unit with a non-empty and an empty result from units.point-selection
When: toggle-point-selection completes at release for each result
Then: candidate lookup returns the complete candidate set at the pointer point through units.point-selection
the row toggles every member of the complete non-empty set; an empty set keeps the current selection; a non-empty result is committed once and an unchanged empty result records no selection change
the pointer phase ends without a command proposal
the test leaves candidate kinds, inclusion, reach, and tie-break to units.point-selection and restates nothing from it
selection layers assert nothing here because the result is one set
Diagnostics: rts-select-order-and-cast-selection-state
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-proposal-log

empty-replace-clears-selection

an empty replacement clears the selection

scenarioonce

Applies to rts-select-order-and-cast.

When a replace selection row returns an empty complete candidate set, the current selection is cleared and committed once. The result distinguishes that change from an already empty selection left unchanged. The contract says the answer binds only through replace rows; where the adoption declares none, this answer is inert and this test asserts nothing.

Test steps and diagnostics

Given: each replace selection row in rts-select-order-and-cast, a non-empty current selection, and an empty complete candidate set
When: the selection gesture completes
Then: the current selection is cleared and committed once
the result record distinguishes clearing a non-empty selection from leaving an already empty selection unchanged
where the adoption declares no replace selection row, this answer is inert and this test asserts nothing
Diagnostics: rts-select-order-and-cast-selection-state
rts-select-order-and-cast-pointer-result

empty-replace-keeps-selection

an empty replacement keeps the selection

scenarioonce

Does not apply to rts-select-order-and-cast: empty selection is clear selection, not keep selection.

context-row-copies-target-and-creates-proposal · move-squad-on-ground

context row `move-squad-on-ground` copies its target into one proposal

scenarioper context-commands row

Applies to the move-squad-on-ground row.

Context row move-squad-on-ground copies the classified ground point or object from battlefield.pointer-target-kinds as its exact target. One proposal is created with command move-squad and the receiver shape selected by the command-receiver answer; its Fixed command rule is at orders.move-squad. The copied target and receiver do not change before placement. The test names both addresses and restates nothing from them.

Test steps and diagnostics

Given: context row move-squad-on-ground and a classified ground snapshot under battlefield.pointer-target-kinds
When: context-order completes at release with no active targeting state
Then: the row copies the classified point or object as the exact target
one proposal is created with command move-squad and the receiver shape selected by the command-receiver answer
the proposal proceeds to queue placement without changing the copied target or receiver
the test leaves classification, reach, and tie-break to battlefield.pointer-target-kinds and command content to orders.move-squad and restates nothing from them
Diagnostics: rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-pointer-result

context-row-copies-target-and-creates-proposal · attack-enemy-squad

context row `attack-enemy-squad` copies its target into one proposal

scenarioper context-commands row

Applies to the attack-enemy-squad row.

Context row attack-enemy-squad copies the classified enemy point or object from battlefield.pointer-target-kinds as its exact target. One proposal is created with command attack-target and the receiver shape selected by the command-receiver answer; its Fixed command rule is at orders.attack-target. The copied target and receiver do not change before placement. The test names both addresses and restates nothing from them.

Test steps and diagnostics

Given: context row attack-enemy-squad and a classified enemy snapshot under battlefield.pointer-target-kinds
When: context-order completes at release with no active targeting state
Then: the row copies the classified point or object as the exact target
one proposal is created with command attack-target and the receiver shape selected by the command-receiver answer
the proposal proceeds to queue placement without changing the copied target or receiver
the test leaves classification, reach, and tie-break to battlefield.pointer-target-kinds and command content to orders.attack-target and restates nothing from them
Diagnostics: rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-pointer-result

context-row-copies-target-and-creates-proposal · harvest-with-workers

context row `harvest-with-workers` copies its target into one proposal

scenarioper context-commands row

Applies to the harvest-with-workers row.

Context row harvest-with-workers copies the classified resource point or object from battlefield.pointer-target-kinds as its exact target. One proposal is created with command harvest and the receiver shape selected by the command-receiver answer; its Fixed command rule is at orders.harvest-resource. The copied target and receiver do not change before placement. The test names both addresses and restates nothing from them.

Test steps and diagnostics

Given: context row harvest-with-workers and a classified resource snapshot under battlefield.pointer-target-kinds
When: context-order completes at release with no active targeting state
Then: the row copies the classified point or object as the exact target
one proposal is created with command harvest and the receiver shape selected by the command-receiver answer
the proposal proceeds to queue placement without changing the copied target or receiver
the test leaves classification, reach, and tie-break to battlefield.pointer-target-kinds and command content to orders.harvest-resource and restates nothing from them
Diagnostics: rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-pointer-result

context-drag-uses-cited-region

dragged context row `Row.id` uses its cited region

one completed phase creates no duplicate proposal

scenarioonce

Applies to rts-select-order-and-cast.

Each completed phase that creates a proposal creates exactly one. A held modifier or update adds no copy. For a targeted verb, the row's after-dispatch result applies after placement or rejection; for a context command, that clause asserts nothing.

Test steps and diagnostics

Given: each completed pointer phase in rts-select-order-and-cast that creates a proposal, including one with a held queue modifier where available
When: the proposal is created, placed or rejected, and any targeted-verb result is applied
Then: the completed phase creates exactly one proposal
a held modifier or update creates no second copy within that phase
for a targeted verb, its after-dispatch result applies after placement or rejection; for a context command, that clause asserts nothing
Diagnostics: rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-plan-state

proposal-submission-stops-at-command-rule

dispatch stops at the cited command rule

scenarioonce

Applies to rts-select-order-and-cast.

Each placed proposal is submitted once to its cited Fixed command rule at its declared place. Permission, cost, range, path, the unreachable case, effect, rejection, and whether a current command stops belong to that rule. Event resolution owns same-instant order. A paired Action legibility adoption asserts nothing here.

Test steps and diagnostics

Given: each placed proposal in rts-select-order-and-cast, including one queued proposal when the adoption can create one
When: the proposal reaches its declared place and is submitted
Then: the proposal is submitted once to its cited Fixed command rule at its declared place
the pointer contract makes no claim about permission, cost, range, path, the unreachable case, effect, rejection, or whether a current command stops after submission
when several proposals share one instant, their order is left to Event resolution
a paired Action legibility adoption asserts nothing here
Diagnostics: rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-plan-state
rts-select-order-and-cast-pointer-result

pointer-result-record-is-complete

the pointer result records the completed phase

scenarioonce

Applies to rts-select-order-and-cast.

Every pointer result records its gesture, phase, snapshot, targeting states, changed selection, proposed command and receiver, target, placement outcome, cancellation, tested target validity, unmatched classification, and available cited game-rule result. An optional circumstance the adoption cannot construct asserts nothing.

Test steps and diagnostics

Given: each completed pointer phase in rts-select-order-and-cast, including every optional circumstance the adoption can construct
When: the pointer result is read after resolution
Then: the result records gesture id, resolving phase, pointer snapshot, prior and final targeting state, and prior and final selection when changed
it records command and receiver when proposed, target, queue modifier or unmodified placement outcome, cancellation when used, and target validity for every targeted verb that reached validity
it records no-matching-row when applicable and the cited game-rule result when available
an optional circumstance the adoption cannot construct asserts nothing
Diagnostics: rts-select-order-and-cast-pointer-result

authority-order-preserves-copies

later stages preserve the earlier snapshot and receiver

scenarioonce

Applies to rts-select-order-and-cast.

The contract's authority order is physical mapping, gesture recognition, cancellation, targeting entry, confirmation, selection or context classification, receiver snapshot, placement, dispatch, game rule, and same-instant event order. Later stages never change an earlier snapshot or receiver; classification can read receiver class without copying the set. Questions and rows describe choices and citations, not another sequence.

Test steps and diagnostics

Given: each completed pointer phase in rts-select-order-and-cast with distinguishable snapshot, receiver, placement, and game-rule data
When: the phase proceeds through every stage it reaches
Then: physical mapping precedes gesture recognition, cancellation, targeting entry, target confirmation, selection or context classification, receiver snapshot, queue placement, command dispatch, game rule, and same-instant event order
a later stage never changes the pointer snapshot or receiver copied earlier
classification can read receiver class without copying the receiver set
questions and rows describe choices and citations but define no second sequence
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-plan-state

empty-collections-and-unasked-questions

absent rows and unasked questions keep their declared meaning

scenarioonce

Applies to rts-select-order-and-cast.

This check reads the adoption shape. Each empty row set has exactly its when-empty meaning. Each gated question the adoption does not answer has exactly its otherwise meaning: without empty-selection, no pointer gesture changes the current world selection; without invalid-target, no chosen ability or verb waits for a world target from the pointer; without queued-command-placement, no pointer modifier adds a command to a waiting plan; without unmodified-command, no pointer command can enter a waiting plan. When the adoption answers a question or fills a row set, that clause asserts nothing.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption document, including each empty and non-empty row set and each gated question it does or does not answer
When: a reviewer compares the adoption shape with every row-set when-empty sentence and every gated-question otherwise sentence
Then: an empty selection-gestures set means no pointer gesture changes the current selection; when non-empty, this clause asserts nothing
an empty context-commands set means no pointer gesture chooses a command directly from its world target; when non-empty, this clause asserts nothing
an empty targeted-verbs set means no chosen verb waits for a pointer target; when non-empty, this clause asserts nothing
an empty queue-modifiers set means no pointer modifier adds a command to a waiting plan; when non-empty, this clause asserts nothing
an empty cancellations set means no action has a separate cancellation meaning in this adoption; when non-empty, this clause asserts nothing
when the adoption does not answer empty-selection, no pointer gesture changes the current world selection; when it answers, this clause asserts nothing
when the adoption does not answer invalid-target, no chosen ability or verb waits for a world target from the pointer; when it answers, this clause asserts nothing
when the adoption does not answer queued-command-placement, no pointer modifier adds a command to a waiting plan; when it answers, this clause asserts nothing
when the adoption does not answer unmodified-command, no pointer command can enter a waiting plan; when it answers, this clause asserts nothing
Diagnostics: rts-select-order-and-cast-declaration-record

selection-and-context-rows-are-disjoint

declaration check: selection and context rows are disjoint

scenarioonce

Applies to rts-select-order-and-cast.

This declaration check reads the adoption, not the running game. Under the contract's mutually exclusive classifications, no selection and context row, two selection rows, or target-first capture and selection or context row can match the same game-facing action, phase, and classification. No two cancellation rows match the same game-facing action and phase in one holding state under the contract's targeting, selection-drag, queued-commands, selection order. Context target kinds for one action and phase, together with any cited receiver class, must be mutually exclusive. One completed phase selects or commands, never both. Any other shape is a defect this test fails by construction.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption, not the running game
When: a reviewer compares every selection row, context row, target-first capture gesture, and cancellation row by its contract matching terms
Then: no selection row and context row match the same game-facing action, phase, and classification
no two selection rows match the same game-facing action, phase, and classification
no target-first capture gesture matches the same game-facing action, phase, and classification as a selection or context row
no two cancellation rows match the same game-facing action and phase in one holding state
for one context action and phase, target-kind values together with any cited receiver class are mutually exclusive
one completed phase therefore selects or commands, never both
any other shape is a defect this test fails by construction
Diagnostics: rts-select-order-and-cast-declaration-record

queue-modifier-targets-declared-rows · queue-orders

declaration check: modifier `queue-orders` names declared commands and is not inert

scenarioper queue-modifiers row

Applies to the queue-orders row.

This declaration check reads the adoption and orders.queueable-pointer-commands, not the running game. The rule must name only declared context-command and targeted-verb rows, and the contract requires it to name at least one declared row. An undeclared target or empty applicability set is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and orders.queueable-pointer-commands, not the running game
When: a reviewer compares every command named by the applicability rule with context-command and targeted-verb row ids
Then: the rule names only declared context-command and targeted-verb rows
the contract requires the rule to name at least one declared row
any undeclared target or empty applicability set is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

cancellation-state-can-exist · cancel-ability-target

declaration check: cancellation `cancel-ability-target` names a state this adoption can hold

scenarioper cancellations row

Applies to the cancel-ability-target row.

This declaration check reads the adoption, not the running game. For cancellation cancel-ability-target in targeting, the adoption has a targeted-verb row, and its result must match that state. Any other shape is a defect this test fails by construction.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and cancellation row cancel-ability-target, not the running game
When: a reviewer compares its active state with the adoption's rows and answers
Then: for active state targeting, the adoption has a targeted-verb row
the result matches that state: targeting with ends-targeting, selection-drag with ends-drag, queued-commands with empties-queue, or selection with empties-selection
any other shape is a defect this test fails by construction
Diagnostics: rts-select-order-and-cast-declaration-record

cancellation-state-can-exist · abort-box-select

declaration check: cancellation `abort-box-select` names a state this adoption can hold

scenarioper cancellations row

Applies to the abort-box-select row.

This declaration check reads the adoption, not the running game. For cancellation abort-box-select in selection-drag, the adoption has a selection gesture that resolves on drag-complete, and its result must match that state. Any other shape is a defect this test fails by construction.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and cancellation row abort-box-select, not the running game
When: a reviewer compares its active state with the adoption's rows and answers
Then: for active state selection-drag, the adoption has a selection gesture that resolves on drag-complete
the result matches that state: targeting with ends-targeting, selection-drag with ends-drag, queued-commands with empties-queue, or selection with empties-selection
any other shape is a defect this test fails by construction
Diagnostics: rts-select-order-and-cast-declaration-record

current-selection-has-a-source

declaration check: current selection has a declared source

scenarioonce

Applies to rts-select-order-and-cast.

This declaration check reads the adoption, not the running game. Under current-selection, at least one selection gesture or a cited load or scene-entry rule must supply the selection. Any other shape is a defect this test fails by construction.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and its selection, load, and scene-entry declarations, not the running game
When: a reviewer checks how a non-empty current selection can first exist
Then: at least one selection gesture or a cited load or scene-entry rule supplies the selection
any other shape is a defect this test fails by construction
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-verb-has-exit · artillery-target

declaration check: targeted verb `artillery-target` has a way to leave targeting

scenarioper targeted-verbs row

Applies to the artillery-target row.

This declaration check reads the adoption, the contract's targeted-verbs description, and abilities.choose-artillery-barrage, not the running game. The description requires every targeting state to be left through leave-targeting, a targeting cancellation row, or the cited start rule. Targeted verb artillery-target must therefore have leave-targeting as its applicable invalid-target answer or after-dispatch value, a targeting cancellation row, or an exit in that cited start rule. Any other shape is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption, the contract's targeted-verbs description, targeted-verb row artillery-target, its start rule, and its cancellation rows, not the running game
When: a reviewer checks every route by which this targeting state can end
Then: the targeted-verbs description requires every targeting state to be left through leave-targeting, a targeting cancellation row, or the cited start rule
for artillery-target, the applicable invalid-target answer or after-dispatch value is leave-targeting, or the adoption has a targeting cancellation row, or abilities.choose-artillery-barrage states an exit
any other shape is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-verb-has-exit · blink-smart-cast

declaration check: targeted verb `blink-smart-cast` has a way to leave targeting

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

This declaration check reads the adoption, the contract's targeted-verbs description, and abilities.choose-blink-smart-cast, not the running game. The description requires every targeting state to be left through leave-targeting, a targeting cancellation row, or the cited start rule. Targeted verb blink-smart-cast must therefore have leave-targeting as its applicable invalid-target answer or after-dispatch value, a targeting cancellation row, or an exit in that cited start rule. Any other shape is a defect this test fails by construction. The test names the address and restates nothing from it.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption, the contract's targeted-verbs description, targeted-verb row blink-smart-cast, its start rule, and its cancellation rows, not the running game
When: a reviewer checks every route by which this targeting state can end
Then: the targeted-verbs description requires every targeting state to be left through leave-targeting, a targeting cancellation row, or the cited start rule
for blink-smart-cast, the applicable invalid-target answer or after-dispatch value is leave-targeting, or the adoption has a targeting cancellation row, or abilities.choose-blink-smart-cast states an exit
any other shape is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-gesture-citation-duty · point-select

declaration check: `point-select` gesture citation states its duty

scenarioper selection-gestures row

Applies to the point-select row.

This declaration check reads the adoption and controls.select-point, not the running game. The citation must satisfy this duty: it recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used. 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 rts-select-order-and-cast adoption and controls.select-point, not the running game
When: a reviewer checks the citation's meaning
Then: controls.select-point recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-gesture-citation-duty · box-select

declaration check: `box-select` gesture citation states its duty

scenarioper selection-gestures row

Applies to the box-select row.

This declaration check reads the adoption and controls.selection-drag, not the running game. The citation must satisfy this duty: it recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used. 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 rts-select-order-and-cast adoption and controls.selection-drag, not the running game
When: a reviewer checks the citation's meaning
Then: controls.selection-drag recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-gesture-citation-duty · add-unit-on-press

declaration check: `add-unit-on-press` gesture citation states its duty

scenarioper selection-gestures row

Applies to the add-unit-on-press row.

This declaration check reads the adoption and controls.add-point-selection, not the running game. The citation must satisfy this duty: it recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used. 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 rts-select-order-and-cast adoption and controls.add-point-selection, not the running game
When: a reviewer checks the citation's meaning
Then: controls.add-point-selection recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-gesture-citation-duty · toggle-unit

declaration check: `toggle-unit` gesture citation states its duty

scenarioper selection-gestures row

Applies to the toggle-unit row.

This declaration check reads the adoption and controls.toggle-point-selection, not the running game. The citation must satisfy this duty: it recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used. 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 rts-select-order-and-cast adoption and controls.toggle-point-selection, not the running game
When: a reviewer checks the citation's meaning
Then: controls.toggle-point-selection recognizes the game-facing pointer action and its completion phase, including drag threshold and area geometry where used
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-candidates-citation-duty · point-select

declaration check: `point-select` candidate citation states its duty

scenarioper selection-gestures row

Applies to the point-select row.

This declaration check reads the adoption and units.point-selection, not the running game. The citation must satisfy this duty: it names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break. 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 rts-select-order-and-cast adoption and units.point-selection, not the running game
When: a reviewer checks the citation's meaning
Then: units.point-selection names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-candidates-citation-duty · box-select

declaration check: `box-select` candidate citation states its duty

scenarioper selection-gestures row

Applies to the box-select row.

This declaration check reads the adoption and units.area-selection, not the running game. The citation must satisfy this duty: it names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break. 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 rts-select-order-and-cast adoption and units.area-selection, not the running game
When: a reviewer checks the citation's meaning
Then: units.area-selection names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-candidates-citation-duty · add-unit-on-press

declaration check: `add-unit-on-press` candidate citation states its duty

scenarioper selection-gestures row

Applies to the add-unit-on-press row.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and units.point-selection, not the running game
When: a reviewer checks the citation's meaning
Then: units.point-selection names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

selection-candidates-citation-duty · toggle-unit

declaration check: `toggle-unit` candidate citation states its duty

scenarioper selection-gestures row

Applies to the toggle-unit row.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and units.point-selection, not the running game
When: a reviewer checks the citation's meaning
Then: units.point-selection names selectable target kinds, point or area inclusion, near-miss reach when used, and a complete tie-break
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-gesture-citation-duty · move-squad-on-ground

declaration check: `move-squad-on-ground` gesture citation states its duty

scenarioper context-commands row

Applies to the move-squad-on-ground row.

This declaration check reads the adoption and controls.context-order, not the running game. The citation must satisfy this duty: it recognizes the game-facing pointer action and its completion phase. 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 rts-select-order-and-cast adoption and controls.context-order, not the running game
When: a reviewer checks the citation's meaning
Then: controls.context-order recognizes the game-facing pointer action and its completion phase
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-gesture-citation-duty · attack-enemy-squad

declaration check: `attack-enemy-squad` gesture citation states its duty

scenarioper context-commands row

Applies to the attack-enemy-squad row.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and controls.context-order, not the running game
When: a reviewer checks the citation's meaning
Then: controls.context-order recognizes the game-facing pointer action and its completion phase
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-gesture-citation-duty · harvest-with-workers

declaration check: `harvest-with-workers` gesture citation states its duty

scenarioper context-commands row

Applies to the harvest-with-workers row.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and controls.context-order, not the running game
When: a reviewer checks the citation's meaning
Then: controls.context-order recognizes the game-facing pointer action and its completion phase
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-target-citation-duty · move-squad-on-ground

declaration check: `move-squad-on-ground` target citation states its duty

scenarioper context-commands row

Applies to the move-squad-on-ground row.

This declaration check reads the adoption and battlefield.pointer-target-kinds, not the running game. The citation must satisfy this duty: it classifies the pointer snapshot, names the exact target, and states reach and a complete tie-break for nearest-within-reach. 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 rts-select-order-and-cast adoption and battlefield.pointer-target-kinds, not the running game
When: a reviewer checks the citation's meaning
Then: battlefield.pointer-target-kinds classifies the pointer snapshot, names the exact target, and states reach and a complete tie-break for nearest-within-reach
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-target-citation-duty · attack-enemy-squad

declaration check: `attack-enemy-squad` target citation states its duty

scenarioper context-commands row

Applies to the attack-enemy-squad row.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and battlefield.pointer-target-kinds, not the running game
When: a reviewer checks the citation's meaning
Then: battlefield.pointer-target-kinds classifies the pointer snapshot, names the exact target, and states reach and a complete tie-break for nearest-within-reach
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-target-citation-duty · harvest-with-workers

declaration check: `harvest-with-workers` target citation states its duty

scenarioper context-commands row

Applies to the harvest-with-workers row.

Test steps and diagnostics

Given: the rts-select-order-and-cast adoption and battlefield.pointer-target-kinds, not the running game
When: a reviewer checks the citation's meaning
Then: battlefield.pointer-target-kinds classifies the pointer snapshot, names the exact target, and states reach and a complete tie-break for nearest-within-reach
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-area-citation-duty

declaration check: `Row.id` area citation states its duty

scenarioper context-commands row

Does not apply to rts-select-order-and-cast: no row in context-commands matches resolves-on drag complete.

context-receiver-condition-citation-duty · harvest-with-workers

declaration check: `harvest-with-workers` receiver-condition citation states its duty

scenarioper context-commands row

Applies to the harvest-with-workers row.

This declaration check reads the adoption and units.worker-class, not the running game. The citation must satisfy this duty: it names the receiver class that limits this row. 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 rts-select-order-and-cast adoption and units.worker-class, not the running game
When: a reviewer checks the citation's meaning
Then: units.worker-class names the receiver class that limits this row
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-command-citation-duty · move-squad-on-ground

declaration check: `move-squad-on-ground` command citation states its duty

scenarioper context-commands row

Applies to the move-squad-on-ground row.

This declaration check reads the adoption and orders.move-squad, not the running game. The citation must satisfy this duty: it names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or rejected effect. 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 rts-select-order-and-cast adoption and orders.move-squad, not the running game
When: a reviewer checks the citation's meaning
Then: orders.move-squad names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or rejected effect
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-command-citation-duty · attack-enemy-squad

declaration check: `attack-enemy-squad` command citation states its duty

scenarioper context-commands row

Applies to the attack-enemy-squad row.

This declaration check reads the adoption and orders.attack-target, not the running game. The citation must satisfy this duty: it names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or rejected effect. 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 rts-select-order-and-cast adoption and orders.attack-target, not the running game
When: a reviewer checks the citation's meaning
Then: orders.attack-target names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or rejected effect
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

context-command-citation-duty · harvest-with-workers

declaration check: `harvest-with-workers` command citation states its duty

scenarioper context-commands row

Applies to the harvest-with-workers row.

This declaration check reads the adoption and orders.harvest-resource, not the running game. The citation must satisfy this duty: it names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or rejected effect. 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 rts-select-order-and-cast adoption and orders.harvest-resource, not the running game
When: a reviewer checks the citation's meaning
Then: orders.harvest-resource names the command, receiver, target, per-target plan owner, permission, unreachable-target result, and complete accepted or rejected effect
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-start-citation-duty · artillery-target

declaration check: `artillery-target` start citation states its duty

scenarioper targeted-verbs row

Applies to the artillery-target row.

This declaration check reads the adoption and abilities.choose-artillery-barrage, not the running game. The citation must satisfy this duty: it names the game action that supplies the verb and any targeting-state replacement or exit it owns. 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 rts-select-order-and-cast adoption and abilities.choose-artillery-barrage, not the running game
When: a reviewer checks the citation's meaning
Then: abilities.choose-artillery-barrage names the game action that supplies the verb and any targeting-state replacement or exit it owns
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-start-citation-duty · blink-smart-cast

declaration check: `blink-smart-cast` start citation states its duty

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

This declaration check reads the adoption and abilities.choose-blink-smart-cast, not the running game. The citation must satisfy this duty: it names the game action that supplies the verb and any targeting-state replacement or exit it owns. 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 rts-select-order-and-cast adoption and abilities.choose-blink-smart-cast, not the running game
When: a reviewer checks the citation's meaning
Then: abilities.choose-blink-smart-cast names the game action that supplies the verb and any targeting-state replacement or exit it owns
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-target-gesture-citation-duty

declaration check: `Row.id` target-gesture citation states its duty

scenarioper targeted-verbs row

Does not apply to rts-select-order-and-cast: no row in targeted-verbs matches order target first.

targeted-confirm-gesture-citation-duty · artillery-target

declaration check: `artillery-target` confirmation citation states its duty

scenarioper targeted-verbs row

Applies to the artillery-target row.

This declaration check reads the adoption and controls.confirm-world-target, not the running game. The citation must satisfy this duty: it recognizes the confirmation action and its completion phase. 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 rts-select-order-and-cast adoption and controls.confirm-world-target, not the running game
When: a reviewer checks the citation's meaning
Then: controls.confirm-world-target recognizes the confirmation action and its completion phase
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-targets-citation-duty · artillery-target

declaration check: `artillery-target` targets citation states its duty

scenarioper targeted-verbs row

Applies to the artillery-target row.

This declaration check reads the adoption and abilities.artillery-valid-ground, not the running game. The citation must satisfy this duty: it names target capture, every valid target, near-miss reach and tie-break when used, and the complete invalid-target test. 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 rts-select-order-and-cast adoption and abilities.artillery-valid-ground, not the running game
When: a reviewer checks the citation's meaning
Then: abilities.artillery-valid-ground names target capture, every valid target, near-miss reach and tie-break when used, and the complete invalid-target test
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-targets-citation-duty · blink-smart-cast

declaration check: `blink-smart-cast` targets citation states its duty

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

This declaration check reads the adoption and abilities.blink-valid-ground, not the running game. The citation must satisfy this duty: it names target capture, every valid target, near-miss reach and tie-break when used, and the complete invalid-target test. 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 rts-select-order-and-cast adoption and abilities.blink-valid-ground, not the running game
When: a reviewer checks the citation's meaning
Then: abilities.blink-valid-ground names target capture, every valid target, near-miss reach and tie-break when used, and the complete invalid-target test
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-area-citation-duty

declaration check: `Row.id` area citation states its duty

scenarioper targeted-verbs row

Does not apply to rts-select-order-and-cast: no row in targeted-verbs matches resolves-on drag complete.

targeted-command-citation-duty · artillery-target

declaration check: `artillery-target` command citation states its duty

scenarioper targeted-verbs row

Applies to the artillery-target row.

This declaration check reads the adoption and abilities.artillery-barrage-command, not the running game. The citation must satisfy this duty: it names the command, receiver, per-target plan owner, permission, cost, unreachable-target result, and complete effect or rejection. 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 rts-select-order-and-cast adoption and abilities.artillery-barrage-command, not the running game
When: a reviewer checks the citation's meaning
Then: abilities.artillery-barrage-command names the command, receiver, per-target plan owner, permission, cost, unreachable-target result, and complete effect or rejection
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

targeted-command-citation-duty · blink-smart-cast

declaration check: `blink-smart-cast` command citation states its duty

scenarioper targeted-verbs row

Applies to the blink-smart-cast row.

This declaration check reads the adoption and abilities.blink-command, not the running game. The citation must satisfy this duty: it names the command, receiver, per-target plan owner, permission, cost, unreachable-target result, and complete effect or rejection. 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 rts-select-order-and-cast adoption and abilities.blink-command, not the running game
When: a reviewer checks the citation's meaning
Then: abilities.blink-command names the command, receiver, per-target plan owner, permission, cost, unreachable-target result, and complete effect or rejection
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

queue-modifier-citation-duty · queue-orders

declaration check: `queue-orders` modifier citation states its duty

scenarioper queue-modifiers row

Applies to the queue-orders row.

This declaration check reads the adoption and controls.queue-command-active, not the running game. The citation must satisfy this duty: it names when the mapped modifier is active, any waiting-plan capacity, and the complete result when no place is available. 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 rts-select-order-and-cast adoption and controls.queue-command-active, not the running game
When: a reviewer checks the citation's meaning
Then: controls.queue-command-active names when the mapped modifier is active, any waiting-plan capacity, and the complete result when no place is available
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

queue-applicability-citation-duty · queue-orders

declaration check: `queue-orders` applicability citation states its duty

scenarioper queue-modifiers row

Applies to the queue-orders row.

This declaration check reads the adoption and orders.queueable-pointer-commands, not the running game. The citation must satisfy this duty: it names every declared context command and targeted verb to which this modifier applies. 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 rts-select-order-and-cast adoption and orders.queueable-pointer-commands, not the running game
When: a reviewer checks the citation's meaning
Then: orders.queueable-pointer-commands names every declared context command and targeted verb to which this modifier applies
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

cancellation-action-citation-duty · cancel-ability-target

declaration check: `cancel-ability-target` action citation states its duty

scenarioper cancellations row

Applies to the cancel-ability-target row.

This declaration check reads the adoption and controls.context-order, not the running game. The citation must satisfy this duty: it recognizes the cancellation action and its completion phase. 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 rts-select-order-and-cast adoption and controls.context-order, not the running game
When: a reviewer checks the citation's meaning
Then: controls.context-order recognizes the cancellation action and its completion phase
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

cancellation-action-citation-duty · abort-box-select

declaration check: `abort-box-select` action citation states its duty

scenarioper cancellations row

Applies to the abort-box-select row.

This declaration check reads the adoption and controls.selection-drag, not the running game. The citation must satisfy this duty: it recognizes the cancellation action and its completion phase. 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 rts-select-order-and-cast adoption and controls.selection-drag, not the running game
When: a reviewer checks the citation's meaning
Then: controls.selection-drag recognizes the cancellation action and its completion phase
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

cancellation-state-citation-duty · cancel-ability-target

declaration check: `cancel-ability-target` state citation states its duty

scenarioper cancellations row

Applies to the cancel-ability-target row.

This declaration check reads the adoption and abilities.pointer-targeting-state, not the running game. The citation must satisfy this duty: it names when the affected targeting, selection-drag, waiting-plan, or selection state exists. 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 rts-select-order-and-cast adoption and abilities.pointer-targeting-state, not the running game
When: a reviewer checks the citation's meaning
Then: abilities.pointer-targeting-state names when the affected targeting, selection-drag, waiting-plan, or selection state exists
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

cancellation-state-citation-duty · abort-box-select

declaration check: `abort-box-select` state citation states its duty

scenarioper cancellations row

Applies to the abort-box-select row.

This declaration check reads the adoption and units.selection-drag-state, not the running game. The citation must satisfy this duty: it names when the affected targeting, selection-drag, waiting-plan, or selection state exists. 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 rts-select-order-and-cast adoption and units.selection-drag-state, not the running game
When: a reviewer checks the citation's meaning
Then: units.selection-drag-state names when the affected targeting, selection-drag, waiting-plan, or selection state exists
a missing duty is a defect this test fails by construction
the test names the address and restates nothing from it
Diagnostics: rts-select-order-and-cast-declaration-record

pointer-command-holds

pointer command holds for the whole run

generalonce

Applies to rts-select-order-and-cast.

Across every completed pointer phase of the audited run in every state the adoption can be in, every completed phase matches at most one row in the contract's precedence; every selection change commits once from the complete candidate set; every proposal keeps its copied snapshot and receiver to its declared place; every cancellation clears only its declared state; every targeting state ends only as declared; and no phase produces two proposals.

Test steps and diagnostics

Holds: every completed pointer phase matched at most one row in the precedence the contract fixes; every selection change committed once from the complete candidate set; every command proposal carried its copied snapshot and receiver unchanged to its declared place; every cancellation cleared only its declared state; every targeting state ended only as declared; no phase produced two proposals
Seeds: ["audit-a","audit-b"]
Scope: every completed pointer phase of the audited run in every state the adoption can be in
Diagnostics: rts-select-order-and-cast-pointer-result
rts-select-order-and-cast-snapshot-log
rts-select-order-and-cast-selection-state
rts-select-order-and-cast-targeting-state
rts-select-order-and-cast-proposal-log
rts-select-order-and-cast-plan-state
rts-select-order-and-cast-cancellation-log

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": "pointer-command",
  "version": 1,
  "summary": "Covers pointer gestures that select things in the world and issue commands to or at the world. It records direct world orders, chosen abilities and verbs, added orders, and cancellation. Physical bindings, camera view, readouts, pathfinding, unit AI, and formations stay elsewhere.",
  "questions": {
    "command-receiver": {
      "asks": "Who receives a command made by pointing at the world?",
      "rationale": "A pointer command may control one standing actor, the current selection, or the pointed place itself.",
      "options": {
        "fixed-actor": {
          "meaning": "One fixed actor or party receives every world command. An ARPG hero moves wherever the ground is clicked.",
          "semantics": "Every proposed command names the actor or party fixed by its cited command rule. No world selection is required to supply a receiver."
        },
        "current-selection": {
          "meaning": "The current world selection receives every command. An RTS order moves the selected squad.",
          "semantics": "The receiver set is the complete current selection. An empty set is a rejected receiver."
        },
        "world-target": {
          "meaning": "The command belongs to the pointed place or object, without a selected actor. A colony work order marks one ore tile for any worker.",
          "semantics": "A proposed command names its world target and no selected receiver. The cited game rule owns any later choice of actor, worker, structure, or world system that carries it out."
        }
      }
    },
    "near-miss-resolution": {
      "asks": "When the pointer just misses a target, what can it choose?",
      "rationale": "The game can require the exact point or choose the nearest candidate inside a declared reach.",
      "options": {
        "exact-point-only": {
          "meaning": "Only the exact pointed place or object counts. A click beside a chest does not choose it.",
          "semantics": "Candidate lookup uses the exact pointer point and applies no near-miss reach."
        },
        "nearest-within-reach": {
          "meaning": "The nearest candidate inside the game's declared reach counts. A click beside a small lever can choose it.",
          "semantics": "Candidate lookup chooses the nearest selectable candidate inside the cited reach and uses the cited complete tie-break."
        }
      }
    },
    "empty-selection": {
      "asks": "The player clicks or drags to choose units and finds nothing there. What happens to the earlier choice?",
      "rationale": "An empty click or box can clear the selection or leave the earlier choice in place. The answer binds only through replace rows; with none, it is inert.",
      "when": {
        "row-count": {
          "selection-gestures": "non-empty"
        }
      },
      "otherwise": "No pointer gesture changes the current world selection.",
      "options": {
        "clear-selection": {
          "meaning": "The current selection is cleared. A tactics click on open ground leaves no unit selected.",
          "semantics": "The declared empty-result consequence is an empty selection."
        },
        "keep-selection": {
          "meaning": "The current selection stays. A colony drag across bare ground leaves the chosen workers selected.",
          "semantics": "The declared empty-result consequence preserves the earlier selection."
        }
      }
    },
    "invalid-target": {
      "asks": "Does the game keep waiting for a place to use the chosen ability or verb?",
      "rationale": "The next point can retry the choice, or the game can return to ordinary pointing.",
      "when": {
        "row-count": {
          "targeted-verbs": "non-empty"
        }
      },
      "otherwise": "No chosen ability or verb waits for a world target from the pointer.",
      "options": {
        "keep-targeting": {
          "meaning": "The game keeps waiting for another point. An ARPG fire spell still waits after the pointer lands outside its range.",
          "semantics": "The invalid-target consequence keeps the same chosen verb active."
        },
        "leave-targeting": {
          "meaning": "The game stops waiting after the invalid point. A tower placement returns to ordinary pointing after a blocked tile.",
          "semantics": "The invalid-target consequence clears the chosen verb."
        }
      }
    },
    "queued-command-placement": {
      "asks": "The player holds the key that adds orders to a line. Where does the added order go?",
      "rationale": "The command may wait behind the full plan or become the next command after the current one.",
      "when": {
        "row-count": {
          "queue-modifiers": "non-empty"
        }
      },
      "otherwise": "No pointer modifier adds a command to a waiting plan.",
      "options": {
        "append-at-end": {
          "meaning": "The command joins the end of the waiting plan. An RTS shift-order adds a final waypoint.",
          "semantics": "The declared placement is after every waiting command for the same plan owner."
        },
        "insert-next": {
          "meaning": "The command becomes next after the current command. A colony emergency repair runs before work already waiting.",
          "semantics": "The declared placement is before every waiting command for the same plan owner."
        }
      }
    },
    "unmodified-command": {
      "asks": "A new order arrives while another order is waiting. What happens without the add-orders key?",
      "rationale": "A plain order can replace the waiting line, join it, or be refused while that owner is busy.",
      "when": {
        "any": [
          {
            "row-count": {
              "context-commands": "non-empty"
            }
          },
          {
            "row-count": {
              "targeted-verbs": "non-empty"
            }
          }
        ]
      },
      "otherwise": "No pointer command can enter a waiting plan.",
      "options": {
        "replaces-waiting": {
          "meaning": "The new order replaces every waiting pointer order for that owner. A hero turns toward the newest clicked destination.",
          "semantics": "The unmodified placement clears waiting pointer commands for the same plan owner."
        },
        "always-appends": {
          "meaning": "The new order joins the end of that owner's waiting line. A colony keeps each new work mark.",
          "semantics": "The unmodified placement is after every waiting pointer command for the same plan owner."
        },
        "rejected-while-busy": {
          "meaning": "The new order is refused while that owner has work waiting. A build tool accepts no second placement until the first clears.",
          "semantics": "An unmodified proposal is rejected while its plan owner has a waiting pointer command."
        }
      }
    }
  },
  "declares": {
    "values": {},
    "rows": {
      "selection-gestures": {
        "description": "Pointer gestures that replace, add, remove, or toggle actors or world objects in the current selection.",
        "when-empty": "No pointer gesture changes the current world selection.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as point-select or box-select."
          },
          "gesture": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game-facing pointer action supplied after physical input mapping, such as select-point or select-area."
          },
          "resolves-on": {
            "type": "string",
            "required": true,
            "options": [
              "press",
              "release",
              "drag-complete"
            ],
            "description": "The pointer phase that settles the selection. A tactics point may settle on release; an RTS box settles when its drag completes."
          },
          "shape": {
            "type": "string",
            "required": true,
            "options": [
              "point",
              "area"
            ],
            "description": "Whether the gesture tests one pointer point or the cited dragged area."
          },
          "change": {
            "type": "string",
            "required": true,
            "options": [
              "replace",
              "add",
              "remove",
              "toggle"
            ],
            "description": "How the selectable results change the current selection. A strategy box may replace it while a modified click adds one unit."
          },
          "gesture-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule recognizing this game-facing press, release, or drag, including any drag threshold and area geometry."
          },
          "candidates-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming selectable target kinds, point or area inclusion, the near-miss reach when used, and a complete tie-break. A point rule may return several candidates, as in double-click select-type."
          }
        }
      },
      "context-commands": {
        "description": "Commands chosen directly from the classified world target under a pointer gesture, such as moving on ground or attacking an enemy.",
        "when-empty": "No pointer gesture chooses a command directly from what lies under it.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as move-on-ground or attack-enemy."
          },
          "gesture": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game-facing pointer action, such as world-command or context-order."
          },
          "resolves-on": {
            "type": "string",
            "required": true,
            "options": [
              "press",
              "release",
              "drag-complete"
            ],
            "description": "The pointer phase that proposes the command. An action RPG may move on release while a colony designation completes as a drag."
          },
          "target-kind": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The mutually exclusive world classification that selects this row, such as ground, enemy, door, or buildable-tile."
          },
          "command": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game command proposed by this row, such as move, basic-attack, open-door, or place-tower."
          },
          "gesture-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule recognizing the game-facing pointer action and its completion phase."
          },
          "target-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule classifying the pointer snapshot, naming the exact target, and stating the reach and tie-break for nearest-within-reach."
          },
          "area-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "resolves-on": [
                  "drag-complete"
                ]
              }
            },
            "description": "The Fixed rule naming the dragged region, its boundary inclusion, and how the region becomes the command target."
          },
          "receiver-condition": {
            "type": "citation",
            "description": "An optional Fixed rule limiting this row to a receiver class, such as worker or soldier."
          },
          "command-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the command, receiver, target, per-target waiting-plan owner, permission, unreachable-target result, and complete accepted or rejected effect."
          }
        }
      },
      "targeted-verbs": {
        "description": "Abilities and verbs that use a pointer-captured world target, whether the verb or the target arrives first. Every targeting state can be left: through leave-targeting, a targeting cancellation row, or the cited start rule.",
        "when-empty": "No chosen ability or verb waits for a world target from the pointer.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as artillery-target or use-key-on-door."
          },
          "verb": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The chosen ability or verb applied to the captured world target."
          },
          "order": {
            "type": "string",
            "required": true,
            "options": [
              "verb-first",
              "target-first"
            ],
            "description": "Whether the verb starts before target capture or arrives from a cited game action after the pointer captures the target."
          },
          "confirm-style": {
            "type": "string",
            "required": true,
            "options": [
              "separate-gesture",
              "at-entry-position"
            ],
            "description": "Whether confirmation needs another pointer gesture or fires from the pointer snapshot captured when this verb entry begins."
          },
          "target-gesture": {
            "type": "string",
            "pattern": "kebab-case",
            "when": {
              "row": {
                "order": [
                  "target-first"
                ]
              }
            },
            "description": "The game-facing pointer action that captures the world target before the verb arrives."
          },
          "confirm-gesture": {
            "type": "string",
            "pattern": "kebab-case",
            "when": {
              "row": {
                "confirm-style": [
                  "separate-gesture"
                ]
              }
            },
            "description": "The game-facing action that separately confirms this target. It may be a pointer gesture or a cited non-pointer action, such as releasing the held ability key."
          },
          "resolves-on": {
            "type": "string",
            "required": true,
            "options": [
              "press",
              "release",
              "drag-complete"
            ],
            "description": "For separate confirmation, the confirming phase. For a target-first row, the capture phase. For verb-first entry-position casting, the completion phase of the cited entry action. A dragged verb also cites its region rule."
          },
          "after-dispatch": {
            "type": "string",
            "required": true,
            "options": [
              "leave-targeting",
              "keep-targeting"
            ],
            "description": "Whether a valid dispatched command ends targeting or keeps the same verb ready for another target. A tower tool may remain active for repeated placement."
          },
          "starts-when-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the game action that supplies the verb. For target-first, this action arrives after target capture."
          },
          "target-gesture-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "order": [
                  "target-first"
                ]
              }
            },
            "description": "The Fixed rule recognizing the target-first pointer action and its capture phase."
          },
          "confirm-gesture-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "confirm-style": [
                  "separate-gesture"
                ]
              }
            },
            "description": "The Fixed rule recognizing the confirmation gesture and its completion phase."
          },
          "targets-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming target capture, every valid target, the near-miss reach and tie-break when used, and the complete invalid-target test."
          },
          "area-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "resolves-on": [
                  "drag-complete"
                ]
              }
            },
            "description": "The Fixed rule naming the dragged region, its boundary inclusion, and how the region becomes the verb's target."
          },
          "command-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming the command, receiver, per-target waiting-plan owner, permission, cost, unreachable-target result, and complete effect or rejection."
          }
        }
      },
      "queue-modifiers": {
        "description": "Game-facing modifier actions that add matching pointer commands to a waiting command plan.",
        "when-empty": "No pointer modifier adds a command to a waiting plan.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as queue-orders or urgent-work-next."
          },
          "modifier-action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The mapped game action held or active when the pointer command completes."
          },
          "modifier-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming when this mapped modifier action is active, any waiting-plan capacity, and what happens when no place is available."
          },
          "applies-to-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming every context command and targeted verb to which this modifier applies; it names at least one declared row."
          }
        }
      },
      "cancellations": {
        "description": "Game-facing actions that end targeting, abort a selection drag, clear waiting pointer commands, or clear the current selection without proposing another command.",
        "when-empty": "No game-facing action has a separate cancellation meaning in this adoption.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A stable game-facing name, such as cancel-ability-target or abort-box-select."
          },
          "action": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "description": "The game-facing pointer or non-pointer action with a cancellation meaning in the cited state."
          },
          "resolves-on": {
            "type": "string",
            "required": true,
            "options": [
              "press",
              "release",
              "drag-cancel"
            ],
            "description": "The game-facing action phase that applies the cancellation."
          },
          "active-state": {
            "type": "string",
            "required": true,
            "options": [
              "targeting",
              "selection-drag",
              "queued-commands",
              "selection"
            ],
            "description": "The pointer-command state in which this row applies; selection holds when the current selection is non-empty. An ability cancel reads targeting; an RTS stop-planning gesture reads queued commands."
          },
          "result": {
            "type": "string",
            "required": true,
            "options": [
              "ends-targeting",
              "ends-drag",
              "empties-queue",
              "empties-selection"
            ],
            "description": "The state change made without another world command. The result matches the row's active state; empties-queue clears the waiting plan named at state-declared-in."
          },
          "action-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule recognizing the cancellation action and its completion phase."
          },
          "state-declared-in": {
            "type": "citation",
            "required": true,
            "description": "The Fixed rule naming when the affected targeting, drag, waiting-plan, or selection state exists."
          }
        }
      }
    }
  },
  "rules": {},
  "origin": "https://opengdd.org/contracts/pointer-command-1",
  "mechanism": [
    "This is the single normative authority for what a pointer press, drag, or release over the world means; how selection, context command, and targeting states advance; where a queue modifier places a command; and what a cancellation clears. Questions and rows describe choices and cite game rules. They do not define another sequence.",
    "A **game-facing pointer action** is the action received after Control options maps a mouse, touch, or stick-driven cursor input. A **pointer phase** is its press, release, completed drag, or cancelled drag. A **pointer snapshot** is the world point and classified object under the pointer at that phase. The broader **game-facing action** also includes a cited non-pointer action that supplies a verb, confirmation, or cancellation; a non-pointer action has one completion phase, recorded as its press unless its cited rule names release. The **current selection** is one set of world objects. It starts empty unless a cited load or scene-entry rule supplies it, lasts until a rule changes it, and may also change through cited control-group recall, unit death, roster change, scene entry, or load. A **selection drag** starts when its cited gesture rule crosses the drag threshold and lasts until that same gesture completes or cancels. A **targeting state** holds one chosen ability or verb, or a target-first snapshot while it waits for the verb. A **command proposal** contains one command, its receiver shape, exact world target, and queue placement. A **waiting plan** contains pointer commands accepted for later execution for the owner named by the cited command rule. The game's Fixed command rules own whether a proposal is accepted and what it does.",
    "### Recognize the gesture",
    "1. Control options maps physical input to one game-facing pointer action. The matching cited gesture rule observes its press, movement, and release. This contract does not inspect device identity. 2. On press, record the pointer snapshot needed by the cited gesture rule. A row that resolves on press proceeds immediately, and no later drag or release result is inferred from that press for this contract. 3. While the pointer moves, the cited rule alone decides whether it remains a point gesture, becomes a drag, or is cancelled. Its cited distance, duration, geometry, coordinate space, and boundary rule are read directly; this adoption contributes no number. A cited gesture rule may emit repeated completed phases while a control is held. 4. On release, create the final pointer snapshot. A release row resolves now. A recognized drag creates one `drag-complete` phase; an aborted drag creates one `drag-cancel` phase belonging to that drag's own game-facing action. One physical sequence cannot produce both a point result and a drag result unless the cited rule creates two distinct game-facing actions.",
    "### Resolve cancellation and targeting",
    "5. At each completed action phase, check cancellation before any other row. A cancellation row matches on three terms of its own: the game-facing action, its resolving phase, and the currently holding active state, checked in this order: targeting, selection-drag, queued-commands, selection. Apply its declared result and end this phase. It proposes no command and performs no selection change beyond `empties-selection`. 6. For `verb-first`, a game action named by `starts-when-declared-in` supplies the verb and begins its targeting entry. For `target-first`, the capture gesture — matched on its game-facing action, phase, and classified snapshot — captures the world target and begins a target-first state; then the cited game action — a verb coin, pie menu, or command card — supplies the verb. A second entry does not change the active targeting state unless the cited start rule explicitly replaces it. 7. While targeting is active, ordinary selection and direct-command rows do not run. Under `separate-gesture`, a matching confirmation action reads the pointer snapshot at its completion moment — for a non-pointer confirmation such as a key release, the pointer's position at that release. Under `at-entry-position`, confirmation reads the entry-time snapshot: the pointer position when a verb-first entry begins or the already captured target for target-first. A `drag-complete` row also reads its cited region rule, and validity is tested on that region. Apply `near-miss-resolution` through `targets-declared-in`, then test validity. A non-matching pointer action has no meaning here unless it matches a cancellation row. 8. For an invalid target, propose no command. Under `keep-targeting`, preserve the active verb. Under `leave-targeting`, clear it. No context-command fallback occurs from the same pointer phase. 9. For a valid target, create one command proposal from the targeted row and its cited rules; under `current-selection` an empty selection makes it one rejected proposal, as in step 12. Preserve the row's `after-dispatch` result with the proposal. A rejected command is still a dispatched proposal, so rejection does not restore targeting unless the cited game rule starts a new instance.",
    "### Resolve selection or a context command",
    "10. With no active targeting state, find the one selection or context row that matches the game-facing action, pointer phase, and classified pointer snapshot. A context row with `receiver-condition` also matches the receiver class named by that citation; receiver class therefore participates in classification when a row cites it. A receiver-conditioned adoption keeps its receiver set homogeneous for that action: when rows cite different receiver classes for one action, phase, and target kind, the selection holds one class at a time under the receiver-condition citation, and issuing different commands per member of one mixed selection is a missing shape recorded in §5. For one game-facing action and phase, selection rows, context rows, and target-first capture gestures have mutually exclusive classifications. Apply `near-miss-resolution` through the row's cited target or candidate rule. If no row matches, change no world-command state and record the unmatched classification in step 16. 11. For a selection row, compute its complete candidate set from the cited point or area rule. With an empty result, a `replace` row applies `empty-selection`; an `add`, `remove`, or `toggle` row always keeps the current selection, because an empty additive result asserts nothing about the earlier choice. With a non-empty result, apply `replace`, `add`, `remove`, or `toggle` to the complete set. Commit the new selection once and end this pointer phase. 12. For a context row, copy its classified point or object as the command target. Under `fixed-actor`, read the fixed receiver from the cited command rule. Under `current-selection`, copy the complete current selection. An empty copy creates one rejected proposal with no world effect and ends at this step; it never reaches queue placement or dispatch. Under `world-target`, attach no selected receiver and read that exact target's plan owner from the cited command rule. Create one command proposal and continue.",
    "### Place and dispatch the command",
    "13. Read queue modifiers only after the command, receiver, and target are fixed. A matching modifier changes placement, not meaning. Under `append-at-end`, place the proposal after every waiting pointer command for the same waiting-plan owner. Under `insert-next`, place it before those waiting commands and after the command already being carried out. The cited modifier rule owns plan capacity and the complete rejected result when no place is available; this contract never drops another command implicitly. 14. With a matching modifier, add the proposal at the position from step 13. Without one, read `unmodified-command`: `replaces-waiting` clears waiting pointer commands for the same owner, `always-appends` places the proposal after them, and `rejected-while-busy` records rejection and stops when one is waiting. A proposal exists once per completed phase; a held modifier or update cannot add another copy within that phase. After a targeted proposal is dispatched, placed, or rejected at this step, apply its row's `after-dispatch` result: `leave-targeting` ends the state and `keep-targeting` preserves it. 15. Submit each dispatched proposal to its cited Fixed command rule. That rule owns permission, cost, range, path request, the unreachable-destination case, effect, rejection, and whether the command already being carried out stops. A queued proposal is submitted when it reaches its declared place. Event resolution owns the order when several proposals share one instant. 16. Record the pointer result: gesture id, resolving phase, pointer snapshot, prior and final targeting state, prior and final selection when changed, command and receiver when proposed, target, queue modifier or unmodified placement outcome, cancellation when used, target validity for every targeted verb that reached a validity test, a no-matching-row result when applicable, and the cited game-rule result when available.",
    "The authority order is therefore: physical mapping, gesture recognition, cancellation, targeting entry, target confirmation, selection or context classification, receiver snapshot, queue placement, command dispatch, game rule, and same-instant event order. A later stage never changes the pointer snapshot or receiver copied by an earlier stage; classification may read receiver class without copying the receiver set."
  ],
  "answers": {
    "command-receiver": "current-selection",
    "near-miss-resolution": "exact-point-only",
    "empty-selection": "clear-selection",
    "invalid-target": "keep-targeting",
    "queued-command-placement": "append-at-end",
    "unmodified-command": "replaces-waiting"
  },
  "values": {},
  "rows": {
    "selection-gestures": [
      {
        "id": "point-select",
        "gesture": "select-point",
        "resolves-on": "release",
        "shape": "point",
        "change": "replace",
        "gesture-declared-in": "controls.select-point",
        "candidates-declared-in": "units.point-selection"
      },
      {
        "id": "box-select",
        "gesture": "select-area",
        "resolves-on": "drag-complete",
        "shape": "area",
        "change": "replace",
        "gesture-declared-in": "controls.selection-drag",
        "candidates-declared-in": "units.area-selection"
      },
      {
        "id": "add-unit-on-press",
        "gesture": "add-point-selection",
        "resolves-on": "press",
        "shape": "point",
        "change": "add",
        "gesture-declared-in": "controls.add-point-selection",
        "candidates-declared-in": "units.point-selection"
      },
      {
        "id": "toggle-unit",
        "gesture": "toggle-point-selection",
        "resolves-on": "release",
        "shape": "point",
        "change": "toggle",
        "gesture-declared-in": "controls.toggle-point-selection",
        "candidates-declared-in": "units.point-selection"
      }
    ],
    "context-commands": [
      {
        "id": "move-squad-on-ground",
        "gesture": "context-order",
        "resolves-on": "release",
        "target-kind": "ground",
        "command": "move-squad",
        "gesture-declared-in": "controls.context-order",
        "target-declared-in": "battlefield.pointer-target-kinds",
        "command-declared-in": "orders.move-squad"
      },
      {
        "id": "attack-enemy-squad",
        "gesture": "context-order",
        "resolves-on": "release",
        "target-kind": "enemy",
        "command": "attack-target",
        "gesture-declared-in": "controls.context-order",
        "target-declared-in": "battlefield.pointer-target-kinds",
        "command-declared-in": "orders.attack-target"
      },
      {
        "id": "harvest-with-workers",
        "gesture": "context-order",
        "resolves-on": "release",
        "target-kind": "resource",
        "command": "harvest",
        "gesture-declared-in": "controls.context-order",
        "target-declared-in": "battlefield.pointer-target-kinds",
        "receiver-condition": "units.worker-class",
        "command-declared-in": "orders.harvest-resource"
      }
    ],
    "targeted-verbs": [
      {
        "id": "artillery-target",
        "verb": "artillery-barrage",
        "order": "verb-first",
        "confirm-style": "separate-gesture",
        "confirm-gesture": "confirm-world-target",
        "resolves-on": "release",
        "after-dispatch": "leave-targeting",
        "starts-when-declared-in": "abilities.choose-artillery-barrage",
        "confirm-gesture-declared-in": "controls.confirm-world-target",
        "targets-declared-in": "abilities.artillery-valid-ground",
        "command-declared-in": "abilities.artillery-barrage-command"
      },
      {
        "id": "blink-smart-cast",
        "verb": "blink",
        "order": "verb-first",
        "confirm-style": "at-entry-position",
        "resolves-on": "press",
        "after-dispatch": "leave-targeting",
        "starts-when-declared-in": "abilities.choose-blink-smart-cast",
        "targets-declared-in": "abilities.blink-valid-ground",
        "command-declared-in": "abilities.blink-command"
      }
    ],
    "queue-modifiers": [
      {
        "id": "queue-orders",
        "modifier-action": "queue-command",
        "modifier-declared-in": "controls.queue-command-active",
        "applies-to-declared-in": "orders.queueable-pointer-commands"
      }
    ],
    "cancellations": [
      {
        "id": "cancel-ability-target",
        "action": "context-order",
        "resolves-on": "release",
        "active-state": "targeting",
        "result": "ends-targeting",
        "action-declared-in": "controls.context-order",
        "state-declared-in": "abilities.pointer-targeting-state"
      },
      {
        "id": "abort-box-select",
        "action": "select-area",
        "resolves-on": "drag-cancel",
        "active-state": "selection-drag",
        "result": "ends-drag",
        "action-declared-in": "controls.selection-drag",
        "state-declared-in": "units.selection-drag-state"
      }
    ]
  },
  "pack": "sha256:d9dfa01c583bd31d11345ee211618019165be830fbf01231f7d81cd93a27538a"
}

RTS select order and cast

Use in your game

The contract behind it

Questions

Who receives a command made by pointing at the world?

When the pointer just misses a target, what can it choose?

The player clicks or drags to choose units and finds nothing there. What happens to the earlier choice?

Does the game keep waiting for a place to use the chosen ability or verb?

The player holds the key that adds orders to a line. Where does the added order go?

A new order arrives while another order is waiting. What happens without the add-orders key?

Selection gestures

Context commands

Targeted verbs

Queue modifiers

Cancellations

pointer command uses actions, phases, snapshots, and states

selection, proposals, and waiting plans keep distinct meanings

selection gesture point-select resolves at its declared phase

selection gesture box-select resolves at its declared phase

selection gesture add-unit-on-press resolves at its declared phase

selection gesture toggle-unit resolves at its declared phase

context command move-squad-on-ground resolves at its declared phase

context command attack-enemy-squad resolves at its declared phase

context command harvest-with-workers resolves at its declared phase

targeted verb artillery-target resolves at its declared phase

targeted verb blink-smart-cast resolves at its declared phase

the cited gesture rule alone classifies motion

one physical sequence produces one pointer result

each repeated completed command phase produces one proposal

cancellation cancel-ability-target applies before any other row

cancellation abort-box-select applies before any other row

verb-first row artillery-target begins from its cited action

verb-first row blink-smart-cast begins from its cited action

target-first row Row.id captures its target before the verb

artillery-target reads the target when confirmation completes

blink-smart-cast confirms from its entry snapshot

dragged verb Row.id uses its cited region

artillery-target resolves a candidate and tests validity

blink-smart-cast resolves a candidate and tests validity

an invalid target keeps targeting

an invalid target leaves targeting

a valid target creates one artillery-target proposal

a valid target creates one blink-smart-cast proposal

artillery-target targeting suppresses ordinary selection and context rows

blink-smart-cast targeting suppresses ordinary selection and context rows

one selection or context row matches without targeting

harvest-with-workers also matches its cited receiver class

selection row point-select commits its complete candidate set once

selection row box-select commits its complete candidate set once

selection row add-unit-on-press commits its complete candidate set once

selection row toggle-unit commits its complete candidate set once

an empty replacement clears the selection

an empty replacement keeps the selection

context row move-squad-on-ground copies its target into one proposal

context row attack-enemy-squad copies its target into one proposal

context row harvest-with-workers copies its target into one proposal

dragged context row Row.id uses its cited region

the cited fixed actor receives each command

the complete current selection receives each command

the exact world target owns each command

candidate lookup uses the exact pointer point

candidate lookup chooses the cited nearest candidate

queue modifier queue-orders appends a matching proposal

queue modifier Row.id inserts a matching proposal next

an unmodified command replaces waiting pointer commands

an unmodified command appends after waiting commands

an unmodified command is accepted only when its plan is not busy

one completed phase creates no duplicate proposal

dispatch stops at the cited command rule

the pointer result records the completed phase

later stages preserve the earlier snapshot and receiver

absent rows and unasked questions keep their declared meaning

declaration check: selection and context rows are disjoint

declaration check: modifier queue-orders names declared commands and is not inert

declaration check: cancellation cancel-ability-target names a state this adoption can hold

declaration check: cancellation abort-box-select names a state this adoption can hold

declaration check: current selection has a declared source

declaration check: targeted verb artillery-target has a way to leave targeting

declaration check: targeted verb blink-smart-cast has a way to leave targeting

declaration check: point-select gesture citation states its duty

selection gesture `point-select` resolves at its declared phase

selection gesture `box-select` resolves at its declared phase

selection gesture `add-unit-on-press` resolves at its declared phase

selection gesture `toggle-unit` resolves at its declared phase

context command `move-squad-on-ground` resolves at its declared phase

context command `attack-enemy-squad` resolves at its declared phase

context command `harvest-with-workers` resolves at its declared phase

targeted verb `artillery-target` resolves at its declared phase

targeted verb `blink-smart-cast` resolves at its declared phase

cancellation `cancel-ability-target` applies before any other row

cancellation `abort-box-select` applies before any other row

verb-first row `artillery-target` begins from its cited action

verb-first row `blink-smart-cast` begins from its cited action

target-first row `Row.id` captures its target before the verb

`artillery-target` reads the target when confirmation completes

`blink-smart-cast` confirms from its entry snapshot

dragged verb `Row.id` uses its cited region

`artillery-target` resolves a candidate and tests validity

`blink-smart-cast` resolves a candidate and tests validity

a valid target creates one `artillery-target` proposal

a valid target creates one `blink-smart-cast` proposal

`artillery-target` targeting suppresses ordinary selection and context rows

`blink-smart-cast` targeting suppresses ordinary selection and context rows

`harvest-with-workers` also matches its cited receiver class

selection row `point-select` commits its complete candidate set once

selection row `box-select` commits its complete candidate set once

selection row `add-unit-on-press` commits its complete candidate set once

selection row `toggle-unit` commits its complete candidate set once

context row `move-squad-on-ground` copies its target into one proposal

context row `attack-enemy-squad` copies its target into one proposal

context row `harvest-with-workers` copies its target into one proposal

dragged context row `Row.id` uses its cited region

queue modifier `queue-orders` appends a matching proposal

queue modifier `Row.id` inserts a matching proposal next

declaration check: modifier `queue-orders` names declared commands and is not inert

declaration check: cancellation `cancel-ability-target` names a state this adoption can hold

declaration check: cancellation `abort-box-select` names a state this adoption can hold

declaration check: targeted verb `artillery-target` has a way to leave targeting

declaration check: targeted verb `blink-smart-cast` has a way to leave targeting

declaration check: `point-select` gesture citation states its duty

declaration check: `box-select` gesture citation states its duty

declaration check: `add-unit-on-press` gesture citation states its duty

declaration check: `toggle-unit` gesture citation states its duty

declaration check: `point-select` candidate citation states its duty

declaration check: `box-select` candidate citation states its duty

declaration check: `add-unit-on-press` candidate citation states its duty

declaration check: `toggle-unit` candidate citation states its duty

declaration check: `move-squad-on-ground` gesture citation states its duty

declaration check: `attack-enemy-squad` gesture citation states its duty

declaration check: `harvest-with-workers` gesture citation states its duty

declaration check: `move-squad-on-ground` target citation states its duty

declaration check: `attack-enemy-squad` target citation states its duty

declaration check: `harvest-with-workers` target citation states its duty

declaration check: `Row.id` area citation states its duty

declaration check: `harvest-with-workers` receiver-condition citation states its duty

declaration check: `move-squad-on-ground` command citation states its duty

declaration check: `attack-enemy-squad` command citation states its duty

declaration check: `harvest-with-workers` command citation states its duty

declaration check: `artillery-target` start citation states its duty

declaration check: `blink-smart-cast` start citation states its duty

declaration check: `Row.id` target-gesture citation states its duty

declaration check: `artillery-target` confirmation citation states its duty

declaration check: `artillery-target` targets citation states its duty

declaration check: `blink-smart-cast` targets citation states its duty

declaration check: `Row.id` area citation states its duty

declaration check: `artillery-target` command citation states its duty

declaration check: `blink-smart-cast` command citation states its duty

declaration check: `queue-orders` modifier citation states its duty

declaration check: `queue-orders` applicability citation states its duty

declaration check: `cancel-ability-target` action citation states its duty

declaration check: `abort-box-select` action citation states its duty

declaration check: `cancel-ability-target` state citation states its duty

declaration check: `abort-box-select` state citation states its duty