Tactics tie

This contract has no numbers to set.

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

• The answer only-first-resolves needs a visible order between events of one class. Add a within-class-rules row that decides which event reaches the target first.

  Forbidden when Within class order is No visible order, and Two events one target is Only first resolves. (a warning, not an error)

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

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

This adoption supplies no test inputs. Every test uses its default inputs.

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

Answers you try on this page do not change this file. To change an adoption, open it in the authoring tool.

{
  "contract": "event-resolution",
  "version": 2,
  "summary": "This contract covers actions and events that happen at the same game moment. It decides their order, ties, interruptions, chain reactions, and refused actions. It also settles missing sources or targets, two removals reaching one target, simultaneous endings, and presentation delays. This contract does not cover individual effects, input buffering, clocks and pausing, displayed facts, or the simulation stages of each game update. The Input forgiveness contract covers input buffering. The Fact list contract covers displayed facts.",
  "questions": {
    "rejected-action-effect": {
      "asks": "An action cannot happen exactly as proposed. What happens by default?",
      "rationale": "The attempt may fail, spend a resource, use time, or continue at a smaller scale. This answer is the default answer. A rejection-cases row can choose another result.",
      "options": {
        "nothing-changes": {
          "meaning": "The refused attempt changes nothing. A tactics unit blocked by a closed gate keeps its stamina and its turn.",
          "semantics": "The refusal changes no game state, spends no cost, and advances no clock. Time already advancing independently may continue."
        },
        "cost-taken": {
          "meaning": "The refused attempt spends its cost and changes nothing else. A card refused after commitment still spends its mana.",
          "semantics": "The refusal applies the action's complete declared cost, produces none of the action's effects, and does not advance a clock because of the refusal."
        },
        "clock-advances": {
          "meaning": "The refused attempt moves time forward and spends no cost. A roguelike hero who walks into a wall still uses a turn.",
          "semantics": "The refusal advances one clock once, applies no cost, and produces none of the action's effects. Every case using this result cites the clock rule in its rejection-cases row."
        },
        "cost-and-clock": {
          "meaning": "The refused attempt spends its cost and moves time forward. A dungeon wand that fails uses one charge and one turn.",
          "semantics": "The refusal applies the complete declared cost and advances one clock once, but produces none of the action's effects. Every case using this result cites the clock rule in its rejection-cases row."
        },
        "derate": {
          "meaning": "The action happens with a smaller result instead of failing. A factory machine on low power makes parts more slowly.",
          "semantics": "The proposal is accepted, not refused. The scale rule cited by its rejection-cases row scales the complete effect and cost, and the event continues through this lifecycle."
        },
        "not-applicable": {
          "meaning": "Every proposed action that this adoption covers is accepted. An arcade blaster always fires because ammunition and cooldown never refuse a shot.",
          "semantics": "No action governed by this adoption has a refusal branch."
        }
      }
    },
    "within-class-order": {
      "asks": "Two events of the same class are ready at the same moment. What decides which one goes first?",
      "rationale": "A class is one kind of event in your event-classes list. The rank orders classes. It does not order two events of one class. Their order can change targets, rewards, and later chains.",
      "options": {
        "stable-index": {
          "meaning": "A named number that does not change decides the order. Strategy effects use priority first, and they use spawn number to decide a tie.",
          "semantics": "Every class with a visible tie has a row naming an integer the event holds when it enters the waiting set. The number may be the event's own or inherited from its source object, such as a relic's acquisition number or a minion's board position. Lower numbers resolve first. An optional second named integer decides between equal first numbers. When no second integer is named, equal first numbers cannot occur, or their order cannot change the result."
        },
        "arrival-order": {
          "meaning": "The event that entered the waiting set first goes first. Card effects triggered together resolve in the order they were added.",
          "semantics": "Earlier admission to the waiting set resolves first. Admission order is stable for the complete instant."
        },
        "map-reading-order": {
          "meaning": "Grid position decides the order. Tied tactics units resolve row by row, starting from the map's first row. Inside one row, they resolve starting from the first column.",
          "semantics": "The grid cited by the class or rank-tie row defines what row and column mean. Its own first row resolves first; within that row, its own first column resolves first."
        },
        "clockwise": {
          "meaning": "Positions resolve clockwise around a fixed center. Four boss hazards start from the direction the arena marks first.",
          "semantics": "The grid cited by the class or rank-tie row defines the center and the first direction. Clockwise angle continues the order, and the row's named stable index decides between events at an equal angle and distance."
        },
        "no-visible-order": {
          "meaning": "No order can change the game result. Racing-game confetti bursts may update in either order because neither affects the race.",
          "semantics": "No event in the class observes another event in the same class during the instant, and every permitted execution order produces the same game state and player-facing result. This includes the case where two such events cannot arise together."
        },
        "declared-random": {
          "meaning": "A declared random draw decides the order. Two creatures with equal speed roll to see which acts first.",
          "semantics": "Each affected class has a within-class-rules row citing the random rule and its complete draw procedure. The result may vary between runs; the cited rule, not container order, selects it."
        }
      }
    },
    "terminal-precedence": {
      "asks": "A win and a loss happen at the same moment. Which ending does the game record?",
      "rationale": "The two ending conditions may be detected by different events. This answer decides the recorded result after both conditions are known.",
      "when": {
        "row-count": {
          "terminal-collisions": "non-empty"
        }
      },
      "otherwise": "No declared ending pair can produce a win and a loss at the same instant.",
      "options": {
        "loss-only": {
          "meaning": "Only the loss is recorded. An arena hero who defeats the boss while reaching zero health loses the run.",
          "semantics": "The lifecycle records only the loss, regardless of event rank or the order in which the two ending conditions were detected."
        },
        "win-only": {
          "meaning": "Only the win is recorded. A racing driver who crosses the finish line while crashing still wins.",
          "semantics": "The lifecycle records only the win, regardless of event rank or the order in which the two ending conditions were detected."
        },
        "both-recorded": {
          "meaning": "Both endings are recorded. A card duel in which both heroes reach zero health records a shared defeat and a completed victory condition.",
          "semantics": "The lifecycle records both the win and the loss. The game's presentation rule decides whether that appears as a draw, one combined result, or two named results."
        }
      }
    },
    "presentation-timing": {
      "asks": "Can an animation or sound delay an event, and can another event pass it?",
      "rationale": "A visual delay and a rules delay are different decisions. The answer decides whether only time changes or order changes too.",
      "when": {
        "row-count": {
          "presentation-driven-events": "non-empty"
        }
      },
      "otherwise": "No animation or sound delays an event or changes the order of events.",
      "options": {
        "never": {
          "meaning": "Presentation never changes game timing or order. An attack resolves at game time even when its animation runs early or late.",
          "semantics": "No named event waits for presentation. The rows record that the game considered these events and declared that they do not wait. An adoption with no rows makes no such declaration. This question is then not asked, and no animation or sound delays an event or changes the order of events."
        },
        "may-delay": {
          "meaning": "The listed events may wait for their animation or sound. Every later event waits until they finish. A card attack resolves after its animation, and later effects keep their order.",
          "semantics": "Only events named by presentation-driven-events wait for a cue of their own. Every event behind a held event in the order waits with it, so the delay cannot let a later event resolve first."
        },
        "may-delay-and-reorder": {
          "meaning": "The listed events may wait for their animation or sound. Later events do not wait for them. A fighting-game cinematic can finish after a later poison pulse has already resolved.",
          "semantics": "Only events named by presentation-driven-events may wait. A later eligible event may resolve before a delayed event, and the delayed event keeps its original payload."
        }
      }
    },
    "two-events-one-target": {
      "asks": "Two events would each remove the same target at this moment. What happens to the second one?",
      "rationale": "The second event may vanish, still count, or create another ending. This answer is the default answer. A same-target-exceptions row can choose another result for its target kind.",
      "when": {
        "any": [
          {
            "row-count": {
              "same-target-cases": "non-empty"
            }
          },
          {
            "row-count": {
              "same-target-exceptions": "non-empty"
            }
          }
        ]
      },
      "otherwise": "No two events in this adoption can each remove the same target at one instant.",
      "options": {
        "only-first-resolves": {
          "meaning": "Only the first event affects the target. Two tactics arrows reach the last enemy, and the later arrow finds no target.",
          "semantics": "The first ordered event applies to the target and removes it. Every later event in the collision applies nothing to that target; its cost and carrier follow their own game rules. Every class that can supply two events to such a collision has a visible order. This means that its within-class-rules row, its rank-ties row, or the default answer to within-class-order gives an order other than no-visible-order."
        },
        "all-resolve-one-ending": {
          "meaning": "Every event applies, but the target is removed once. Two arena hits both count before one enemy defeat is recorded.",
          "semantics": "All events in the collision apply to the target in order. Removal is deferred until the collision group ends and is recorded once."
        },
        "all-resolve-each-ending": {
          "meaning": "Every event applies, and each event records its own removal result. Two arcade lasers can each award a break bonus from one target.",
          "semantics": "Every event in the collision applies in order and records its own declared removal consequence, even after an earlier event recorded one."
        }
      }
    },
    "caused-events": {
      "asks": "An event happening now causes another event due at this moment. When does the new event resolve?",
      "rationale": "A chain can continue immediately, join the normal order, or wait for the next game moment.",
      "when": {
        "row-count": {
          "caused-event-kinds": "non-empty"
        }
      },
      "otherwise": "No non-interrupt event in this adoption causes another event due at the same instant.",
      "options": {
        "resolves-now": {
          "meaning": "The new event resolves inside the event that caused it. A card's defeat effect draws a replacement before the next waiting card effect.",
          "semantics": "The caused event finishes inside the event that caused it, before the next waiting event. Every caused-event row cites a finite chain bound."
        },
        "waits-for-its-place": {
          "meaning": "The new event joins its normal place in the current order. An arena enemy activated early can attack later in the same moment.",
          "semantics": "The caused event resolves in its declared class's place, this instant or the next. Every caused-event row cites a finite chain bound."
        },
        "next-instant": {
          "meaning": "The new event always waits for the next game moment. A factory alarm raised now closes the conveyor gate on the next update.",
          "semantics": "Every caused event is admitted to the next instant and none of its effects resolve during the instant that created it. Every caused-event row cites a finite chain bound."
        }
      }
    },
    "interrupt-entry": {
      "asks": "An interrupt can stop or replace an event that is already happening. When does the interrupt take effect?",
      "rationale": "An interrupt needs a fixed entry point before it can stop or replace the event already in progress.",
      "when": {
        "row-count": {
          "interrupts": "non-empty"
        }
      },
      "otherwise": "No event in this adoption stops or replaces another event once it has been selected to resolve, at any point including before its first effect.",
      "options": {
        "before-next-effect": {
          "meaning": "The interrupt takes effect before the next effect of the current event. A card secret counters a spell before its damage applies.",
          "semantics": "At each declared effect boundary, a valid interrupt resolves before the next effect of the active event. The interrupt row then stops or replaces the active event."
        },
        "after-current-effect": {
          "meaning": "The current effect finishes before the interrupt takes effect. A parry accepts the sword's contact, prevents the remaining damage, and replaces it with stagger.",
          "semantics": "The active effect commits first. A valid interrupt then resolves at the following declared boundary and stops or replaces every remaining effect of the active event."
        },
        "at-normal-rank": {
          "meaning": "The interrupt joins the normal event order. A factory emergency stop waits for the safety rank, then cancels later machine work.",
          "semantics": "The interrupt joins this instant when its class is current or has not passed, and otherwise joins the next instant. When it joins the next instant, the active event finishes unchanged in this one and the interrupt stops or replaces only events of its active class that are still waiting or active when it resolves. It remains an interrupt creation path, so the caused-events answer does not govern it."
        }
      }
    },
    "orphaned-events": {
      "asks": "An event loses the source or target it needs. What happens by default?",
      "rationale": "A queued card effect or tactics shot can still be waiting after its source or target is gone. The result must not depend on which object the game removed first.",
      "when": {
        "row-count": {
          "orphan-cases": "non-empty"
        }
      },
      "otherwise": "No event in this adoption can lose its required source or target while waiting or resolving.",
      "options": {
        "resolves-what-remains": {
          "meaning": "The event still resolves with the state that remains. A card's queued effect continues after its minion leaves play.",
          "semantics": "The event keeps its captured payload. A missing source or target is unavailable, effects that require it are skipped, and every independent effect still resolves. This is the default answer unless the orphan-cases row chooses another result."
        },
        "is-canceled": {
          "meaning": "The event is canceled. A homing shot disappears when its only target leaves play before impact.",
          "semantics": "The event produces no further effect after the required source or target becomes unavailable. Costs already committed are not restored by this contract. This is the default answer unless the orphan-cases row chooses another result."
        }
      }
    }
  },
  "declares": {
    "values": {},
    "rows": {
      "event-classes": {
        "description": "The classes of events that are ordered at one instant. A lower rank resolves first. If your game resolves the higher number first, reverse the numbers once in this list, so that the class that resolves first has the lowest rank. Two classes may share a rank only when one rank-ties row declares the shared rank. An event that represents a possible ending does not record the ending when it resolves.",
        "when-empty": "An empty event-classes list is never a behavior choice: this adoption requires at least one row, and a reviewer rejects a file without it.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the event class in your game's words, such as card-effects or enemy-removals."
          },
          "rank": {
            "type": "integer",
            "required": true,
            "description": "The class position, lowest first. Equal ranks are allowed only with one matching rank-ties row."
          },
          "label": {
            "type": "string",
            "required": true,
            "description": "The event class in your game's words. A card duel might use triggered effects."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules name the class and the events that belong to it."
          }
        }
      },
      "within-class-rules": {
        "description": "Classes that use an order different from the default answer to within-class-order, or that must name the data that the default answer compares. A class that uses a stable number, map order, clockwise order, a declared random draw, or a custom game rule has a row whenever a visible tie can occur.",
        "when-empty": "Every event class uses the default answer to within-class-order.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for this class-specific order in your game's words, such as trigger-board-order."
          },
          "class-id": {
            "type": "string",
            "required": true,
            "unique": true,
            "description": "The id of the affected event class."
          },
          "order": {
            "type": "string",
            "required": true,
            "options": [
              "stable-index",
              "arrival-order",
              "map-reading-order",
              "clockwise",
              "no-visible-order",
              "declared-random",
              "game-rule"
            ],
            "description": "The class-specific order. A custom game rule is available in this field, not as the default answer."
          },
          "index-name": {
            "type": "string",
            "when": {
              "row": {
                "order": [
                  "stable-index",
                  "clockwise"
                ]
              }
            },
            "description": "For stable-index, the first named number. For clockwise, the stable number that decides between events at an equal angle and distance."
          },
          "second-index-name": {
            "type": "string",
            "required": false,
            "description": "An optional stable second number that decides between equal first numbers under stable-index. Omit it for every other order."
          },
          "grid-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "order": [
                  "map-reading-order",
                  "clockwise"
                ]
              }
            },
            "description": "Where your game's rules state the grid's own first row and first column, or the center, the first direction, and the clockwise sense. The cited rule is your adopted Grid and direction rule."
          },
          "rule-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "order": [
                  "declared-random",
                  "game-rule"
                ]
              }
            },
            "description": "Where your game's rules state the order. For declared-random, the rules state the complete draw that produces one total order for the instant. For game-rule, the rules state one total deterministic order. The cited rule must state the order itself. It must not refer back to this row."
          }
        }
      },
      "rank-ties": {
        "description": "Every rank shared by two or more event classes, with one tie-break for those classes.",
        "when-empty": "No two event classes share a rank.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the shared-rank group in your game's words, such as attack-initiative."
          },
          "rank": {
            "type": "integer",
            "required": true,
            "unique": true,
            "description": "The rank shared by the named classes."
          },
          "class-ids": {
            "type": "string",
            "required": true,
            "description": "The comma-separated ids of every event class at this rank, each listed once."
          },
          "tie-break": {
            "type": "string",
            "required": true,
            "options": [
              "stable-index",
              "arrival-order",
              "map-reading-order",
              "clockwise",
              "no-visible-order",
              "declared-random",
              "game-rule"
            ],
            "description": "The order used across all events of the tied classes at this rank."
          },
          "index-name": {
            "type": "string",
            "when": {
              "row": {
                "tie-break": [
                  "stable-index",
                  "clockwise"
                ]
              }
            },
            "description": "The stable number compared across tied classes, or the stable number that decides between events at an equal clockwise position."
          },
          "second-index-name": {
            "type": "string",
            "required": false,
            "description": "An optional stable second number that decides between equal first numbers under stable-index. Omit it for every other tie-break."
          },
          "grid-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "tie-break": [
                  "map-reading-order",
                  "clockwise"
                ]
              }
            },
            "description": "Where your game's rules state the grid's own first row and first column, or the center, the first direction, and the clockwise sense. The cited rule is your adopted Grid and direction rule."
          },
          "rule-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "tie-break": [
                  "declared-random",
                  "game-rule"
                ]
              }
            },
            "description": "Where your game's rules state the order. For declared-random, the rules state the complete draw that produces one total order for the instant. For game-rule, the rules state one total deterministic order. The cited rule must state the order itself. It must not refer back to this row."
          }
        }
      },
      "rejection-cases": {
        "description": "Named action-proposal cases that override the default answer or supply the scale or clock citation that the default answer requires.",
        "when-empty": "No named case overrides the default answer. A reviewer rejects an empty list when a case with the result derate, clock-advances, or cost-and-clock can occur, because that result requires its citation row.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the proposal case in your game's words, such as blocked-movement or low-power-crafting."
          },
          "result": {
            "type": "string",
            "required": true,
            "options": [
              "nothing-changes",
              "cost-taken",
              "clock-advances",
              "cost-and-clock",
              "derate"
            ],
            "description": "The result for this case. It may repeat the default answer only to carry a required scale or clock citation. A case in which the action always happens as proposed has no row."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules identify this case and say when it applies."
          },
          "scale-rule-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "result": [
                  "derate"
                ]
              }
            },
            "description": "Where your game's rules say how the complete effect and cost are scaled."
          },
          "clock-rule-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "result": [
                  "clock-advances",
                  "cost-and-clock"
                ]
              }
            },
            "description": "Where your game's rules for the clock or for turns name exactly one advance that this refusal causes."
          }
        }
      },
      "terminal-collisions": {
        "description": "Pairs of win and loss conditions that can become true in one instant.",
        "when-empty": "A win and a loss cannot happen at the same instant in this adoption.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for this ending collision in your game's words, such as both-heroes-at-zero."
          },
          "win-condition": {
            "type": "string",
            "required": true,
            "description": "The winning condition in your game's words, such as boss defeated."
          },
          "loss-condition": {
            "type": "string",
            "required": true,
            "description": "The losing condition in your game's words, such as hero defeated."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules name both ending conditions and show how both can become true at one instant."
          }
        }
      },
      "same-target-cases": {
        "description": "Target kinds for which two events can each be enough to remove the same target at one instant.",
        "when-empty": "No same-target case that uses the default answer to two-events-one-target is declared. The same-target-exceptions rows, if any, are the only declared collisions.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the target case in your game's words, such as unit-under-two-arrows."
          },
          "target-kind": {
            "type": "string",
            "required": true,
            "unique": true,
            "description": "The target kind, such as arena enemies or breakable cover."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules show how two events at the same instant can each remove this target kind."
          }
        }
      },
      "same-target-exceptions": {
        "description": "Target kinds that use a result different from the default answer to two-events-one-target.",
        "when-empty": "Every declared same-target case uses the default answer to two-events-one-target.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the exception in your game's words, such as player-contact."
          },
          "target-kind": {
            "type": "string",
            "required": true,
            "unique": true,
            "description": "The non-overlapping target kind covered by this exception."
          },
          "resolution": {
            "type": "string",
            "required": true,
            "options": [
              "only-first-resolves",
              "all-resolve-one-ending",
              "all-resolve-each-ending"
            ],
            "description": "The result used for this target kind instead of the default answer."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules name the target kind and its collision at one instant."
          }
        }
      },
      "presentation-driven-events": {
        "description": "Events whose relation to an animation or sound is explicitly declared, including events declared never to wait.",
        "when-empty": "No presentation timing rule is declared for an event in this adoption, so presentation does not delay an event or change event order.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the event and presentation case in your game's words, such as card-attack-animation."
          },
          "event-class": {
            "type": "string",
            "required": true,
            "description": "The id of the event class whose timing is compared with presentation."
          },
          "presentation-cue": {
            "type": "string",
            "required": true,
            "description": "The animation or sound in your game's words, such as a card attack animation."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules relate the event's game timing to its presentation cue and show that the cue finishes in finite game time or real time."
          }
        }
      },
      "caused-event-kinds": {
        "description": "Non-interrupt events that can create another event due during the instant that created it.",
        "when-empty": "No non-interrupt event creates another event due in the same instant.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the chain in your game's words, such as enemy-activation-to-attack."
          },
          "event-class": {
            "type": "string",
            "required": true,
            "description": "The class of the newly caused event."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules name the cause, the new event, and the finite bound on repeated caused events."
          }
        }
      },
      "interrupts": {
        "description": "Events created through the interrupt path that can stop or replace another event at a declared effect boundary, including the boundary before its first effect.",
        "when-empty": "No event stops or replaces another event after resolution begins or before its first effect.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the interrupt in your game's words, such as counter-secret or sword-parry."
          },
          "active-class": {
            "type": "string",
            "required": true,
            "description": "The event class that can be interrupted."
          },
          "interrupt-class": {
            "type": "string",
            "required": true,
            "description": "The event class of the interrupt."
          },
          "boundary-granularity": {
            "type": "string",
            "required": true,
            "description": "The smallest named boundary the interrupt can use, such as before the first effect, after each hit, or at each crossed tile edge."
          },
          "result": {
            "type": "string",
            "required": true,
            "options": [
              "stop-original",
              "replace-remaining-effects"
            ],
            "description": "Whether the interrupt ends the active event or substitutes a cited set of effects for what remains."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules name the validity window, the effect boundaries, and the stop result."
          },
          "replacement-declared-in": {
            "type": "citation",
            "when": {
              "row": {
                "result": [
                  "replace-remaining-effects"
                ]
              }
            },
            "description": "Where your game's rules state every replacement effect and its order."
          }
        }
      },
      "orphan-cases": {
        "description": "Events that can lose a required source or target while waiting or resolving. Each row selects its own result, so one adoption can hold cases with different results.",
        "when-empty": "No event can lose a required source or target while waiting or resolving.",
        "record": {
          "id": {
            "type": "string",
            "required": true,
            "pattern": "kebab-case",
            "unique": true,
            "description": "A short name for the missing-object case in your game's words, such as trigger-after-source-loss."
          },
          "event-class": {
            "type": "string",
            "required": true,
            "description": "The event class that may lose its required source or target."
          },
          "missing": {
            "type": "string",
            "required": true,
            "options": [
              "source",
              "target",
              "source-or-target"
            ],
            "description": "Which required game object may become unavailable while the event waits or resolves."
          },
          "resolution": {
            "type": "string",
            "required": true,
            "options": [
              "default",
              "resolves-what-remains",
              "is-canceled"
            ],
            "description": "Use the default answer, or choose another answer for this row."
          },
          "declared-in": {
            "type": "citation",
            "required": true,
            "description": "Where your game's rules identify this case. The rules say when the case applies. The rules name the captured payload, which is the set of values that the event keeps from the moment of its creation. The rules state the source or target requirement."
          }
        }
      }
    }
  },
  "rules": {
    "visible-first-needs-order": {
      "forbid": {
        "all": [
          {
            "flag": {
              "within-class-order": [
                "no-visible-order"
              ]
            }
          },
          {
            "flag": {
              "two-events-one-target": [
                "only-first-resolves"
              ]
            }
          }
        ]
      },
      "severity": "warning",
      "message": "The answer only-first-resolves needs a visible order between events of one class. Add a within-class-rules row that decides which event reaches the target first."
    }
  },
  "origin": "https://opengdd.org/contracts/event-resolution-2",
  "mechanism": [
    "This text decides the order of the steps for how a proposed action becomes a resolved event, how waiting events are ordered, where a tie is decided, where an interrupt enters, and what happens to an orphan. The questions and rows supply choices and cited game rules. They do not change the order.",
    "An **instant** is one moment the game treats as simultaneous. A **proposal** is an action requested by an actor. A **waiting event** has been accepted for an instant but has not begun resolving. An **active event** is currently applying its ordered effects. An **effect boundary** is a point named by a game rule at which an interrupt may enter; one exists before the event's first effect. An **orphan** is an event whose required source or target is no longer available. An **ending event** represents a possible match outcome, but its resolution records nothing. Step 15 is the sole outcome-recording step and reads final settled state: a single ending records there through the game's own cited rule, and a declared collision records through `terminal-precedence`.",
    "A move through three tiles can be modeled as one effect per crossed tile edge. An overwatch shot can then name the edge where it enters. Each interrupt row carries that boundary granularity instead of leaving the decomposition implicit.",
    "A turn-based game has three of the cases of this contract under its own names. A tie on initiative is the question of order at one instant. A skipped turn is a refused action. A turn boundary is an instant like any other instant.",
    "### Propose and admit",
    "1. Read the proposed action against its Fixed game rules. A matching `rejection-cases` row supplies its result; otherwise apply the default answer to `rejected-action-effect` once. `nothing-changes`, `cost-taken`, `clock-advances`, and `cost-and-clock` end the proposal without creating an event. `derate` accepts a scaled action and continues. `not-applicable` admits every proposal that this adoption covers. Repeating `nothing-changes` from the same state produces the same result, because the first refusal changed nothing. For every answer, the same proposal refused from an identical pre-attempt state produces the same result. This idempotence is an obligation of the adoption, not a description of every observed game.",
    "2. For an accepted action, commit its ordinary cost at the point named by its game rule. Create its event payload once. The payload captures every value that must stay available after a later loss of the source; uncaptured state is read only when an effect resolves.",
    "3. Assign every event to its declared class and due instant. Events already due when the instant opens enter its waiting set. An event created after the instant opens has one of two admission paths. A valid `interrupts` row creates an interrupt event; the interrupt entry answer governs it. Every other newly created event follows `caused-events`. The caused-event rows and their `otherwise` sentence exclude declared interrupts.",
    "### Order the waiting set",
    "4. Select the lowest rank among eligible waiting events. If several classes share that rank, the matching `rank-ties` row produces one total order over all events in those tied classes. A `no-visible-order` tie may use any order only because the result cannot expose it.",
    "5. Within each class's remaining events at the selected rank, apply that class's `within-class-rules` row or the default answer to `within-class-order`, and select the first event without changing its payload. Container order in the adoption file never selects an event. Where a `rank-ties` row produced one total order over the tied classes' events in step 4, that order already decides each tied class's internal sequence; a tied class under such an order carries no `within-class-rules` row, and a reviewer rejects such a row because it has no effect.",
    "6. Apply presentation waiting to the selected event. `presentation-timing.otherwise` admits it immediately. Under `may-delay`, an unfinished cue holds that event and every event behind it in the order from steps 4–5. Under `may-delay-and-reorder`, temporarily skip only the named event and return to step 4; later eligible events may pass it. Under `never`, presentation does not hold it. A held event becomes eligible again when its cited cue finishes. The instant waits and cannot close while any presentation-held event remains. Carrying it to a later instant would invent a new game-time rule, so this branch waits instead.",
    "7. Form any same-target collision group containing the selected event. Under `only-first-resolves`, only the first event keeps the target. Under `all-resolve-one-ending`, removal waits until the complete group resolves. Under `all-resolve-each-ending`, every event keeps its own removal consequence. A matching exception row replaces the default answer.",
    "### Check the event and resolve it",
    "8. Settle the same-target decision before the general orphan check. Later events suppressed by `only-first-resolves` apply nothing to that target. The other two answers keep the target available to every member of the collision group. A removal inside that group never turns another member into an orphan. Until an `all-resolve-one-ending` group ends, its target is live for non-member rules too; a non-member resolving before deferred removal therefore reads a live target.",
    "9. Check the selected event's required source and target after its collision group is known, before its first effect, and again at every effect boundary. The matching `orphan-cases` row selects its own result or the default answer to `orphaned-events`. `resolves-what-remains` skips only effects that require the missing object. `is-canceled` removes a waiting event or discards an active event's remaining effects. This continuous check covers a unit killed midway through a cast. A missing object outside the declared cases is an invalid adoption, not an implied result.",
    "10. Make the selected event active and visit the boundary before its first effect. If it continues, apply effects in the order stated by its Fixed game rule. After each effect, commit that effect before reaching the next declared boundary. An ending event follows the same ordering and boundary rules, but its resolution records nothing.",
    "11. At each boundary, discover every valid interrupt and create it through the interrupt path in step 3. When several are valid, select lowest rank first, apply the shared-rank event order when needed, then the selected class's within-class order. Under `before-next-effect`, the selected interrupt enters before the next effect, including before the first. Under `after-current-effect`, the just-finished effect remains committed. Under `at-normal-rank`, place it by the same current-or-next-instant rule as `waits-for-its-place`, then return to step 4. The active event advances only to boundaries its interrupt row permits while that interrupt waits.",
    "12. An interrupt entering at the current boundary keeps presentation waiting, same-target collision grouping, continuous orphan checks, and its own boundaries: it passes through steps 6–11 before its result changes the interrupted event. `stop-original` discards every remaining original effect. `replace-remaining-effects` discards them and installs the complete cited replacement. Already committed effects and costs remain. The cited interrupt rule supplies a finite chain bound, and only one selected interrupt resolves at a time. A presentation skip of an interrupt returns to the interrupted event's boundary, not to step 4.",
    "13. When an effect causes another event due now, apply `caused-events`. `resolves-now` resolves it at the current boundary before the active event continues. `waits-for-its-place` adds it to the current waiting set when its declared class is current or has not passed, otherwise to the next instant. `next-instant` always adds it to the next instant. Every route creates the caused event once and obeys the row's finite chain bound. A common design gives all caused events one class with the last rank and resolves that class until it is empty.",
    "14. Finish the active event. Apply any deferred target removal required by its same-target group, record each selected consequence once, and remove the event from the waiting set. Return to step 4. If only presentation-held events remain, wait for a cited cue; a `may-delay-and-reorder` skip ends as soon as that event's cue finishes. Continue until the waiting set is empty.",
    "### Settle the instant",
    "15. After the waiting set is empty, the game's own cited ending rules record any single ending that holds in the final settled state; this contract does not re-derive them. Then read each `terminal-collisions` row's `win-condition` and `loss-condition` from that state. When both hold, record only the loss, only the win, or both according to `terminal-precedence`, overriding the single-ending recording for that pair. This is the only step at which a match outcome is recorded; class rank and ending-event resolution never override it.",
    "16. Commit the instant's final state and the next-instant waiting set together. No event from the closed instant may later re-enter it. That rule never applies to a presentation-held event, because step 14 forbids closure while the event remains held. Presentation may continue after commitment only when its cited rule cannot change gameplay state or order.",
    "Every settlement report carries the instant, event id, class, rank, tie-break when used, within-class order, source and target availability, effects applied, interrupt and replacement when present, caused-event destination, removal result, and terminal result when present."
  ],
  "pack": "sha256:bb1a678a2812b734ff07d2bc2613237bda360ff8489b7f56b0e5d808bf5a6fe0",
  "answers": {
    "rejected-action-effect": "clock-advances",
    "within-class-order": "stable-index",
    "two-events-one-target": "only-first-resolves",
    "interrupt-entry": "after-current-effect",
    "orphaned-events": "is-canceled"
  },
  "values": {},
  "rows": {
    "event-classes": [
      {
        "id": "reactions",
        "rank": 0,
        "label": "Reaction moves",
        "declared-in": "tactics.reactions"
      },
      {
        "id": "movement",
        "rank": 1,
        "label": "Movement",
        "declared-in": "tactics.movement"
      },
      {
        "id": "light-attacks",
        "rank": 2,
        "label": "Light attacks",
        "declared-in": "tactics.light-attacks"
      },
      {
        "id": "heavy-attacks",
        "rank": 2,
        "label": "Heavy attacks",
        "declared-in": "tactics.heavy-attacks"
      },
      {
        "id": "removals",
        "rank": 3,
        "label": "Removals",
        "declared-in": "tactics.removals"
      }
    ],
    "rank-ties": [
      {
        "id": "attack-initiative",
        "rank": 2,
        "class-ids": "light-attacks, heavy-attacks",
        "tie-break": "map-reading-order",
        "grid-declared-in": "tactics.grid"
      }
    ],
    "rejection-cases": [
      {
        "id": "blocked-movement",
        "result": "clock-advances",
        "declared-in": "tactics.blocked-movement",
        "clock-rule-declared-in": "tactics.turn-clock"
      }
    ],
    "same-target-cases": [
      {
        "id": "unit-under-two-arrows",
        "target-kind": "unit",
        "declared-in": "tactics.arrow-collisions"
      }
    ],
    "interrupts": [
      {
        "id": "sword-parry",
        "active-class": "heavy-attacks",
        "interrupt-class": "reactions",
        "boundary-granularity": "after-each-hit",
        "result": "replace-remaining-effects",
        "declared-in": "tactics.parry-window",
        "replacement-declared-in": "tactics.parry-stagger"
      }
    ],
    "orphan-cases": [
      {
        "id": "homing-shot-without-target",
        "event-class": "light-attacks",
        "missing": "target",
        "resolution": "is-canceled",
        "declared-in": "tactics.homing-shot"
      }
    ],
    "within-class-rules": [],
    "terminal-collisions": [],
    "same-target-exceptions": [],
    "presentation-driven-events": [],
    "caused-event-kinds": []
  }
}