@opencharacter/cwn-srd 0.0.0-stage → 0.2.0

package/rules/magic.yaml

@@ -0,0 +1,207 @@
+# The optional magic rules: mages (Spellcaster), summoners (Summoner) and the Graced. Each
+# cybernetic system lowers a mage's or summoner's Effort, and a Graced's art points, by its
+# System Strain, at least one point each.
+contentTypes:
+  # A spell the mage knows. Prepared spells can be cast.
+  spell:
+    fields:
+      # How long casting Commits Effort: for the day, the scene, either (the caster picks), or no
+      # Effort at all.
+      effort: { type: enum, values: [day, scene, either, none], required: true }
+      duration:
+        type: enum
+        open: true
+        values: [instant, scene, concentration, rounds]
+        required: true
+    state:
+      prepared: { type: boolean, default: false }
+    actions:
+      - use: cast-spell
+
+  # A Graced art, bought with art points.
+  art:
+    fields:
+      cost: { type: integer, required: true, min: 1 }
+
+  # A spirit the summoner has called: its manifestation, how it was summoned and its powers.
+  spirit:
+    nameFrom: label
+    fields:
+      # The powers of a spirit without the core spirit's `powers` choice (a homebrew spirit's).
+      powerCount: { type: integer, default: 0, min: 0 }
+    state:
+      label: { type: string, default: '' }
+      form:
+        type: enum
+        values: [spirit-1, spirit-2, spirit-3, physical-1, physical-2, physical-3]
+        default: spirit-1
+      ritual: { type: boolean, default: true }
+    computed:
+      # The Effort a summoning Commits for the day: one per power, less one for a ritual
+      # summoning, less the Summon skill, at least 1.
+      cost:
+        type: integer
+        formula: >-
+          max(1, (item.id == @spirits.spirit ? size(picksOf('powers')) : item.powerCount)
+            - (self.ritual ? 1 : 0) - max(0, skills.summon.level))
+    actions:
+      - use: summon-spirit
+
+  # A spirit power: each adds one point to a spirit's cost.
+  spiritPower:
+    grantOnly: true
+    copies: { max: 0 }
+    fields:
+      minLevel: { type: integer, default: 1, min: 1 }
+      physicalOnly: { type: boolean, default: false }
+
+fields:
+  magic.mage: { type: boolean, formula: 'false' }
+  magic.summoner: { type: boolean, formula: 'false' }
+  magic.graced: { type: boolean, formula: 'false' }
+  # Each implanted system costs its System Strain, at least one point.
+  magic.cyberPenalty:
+    type: integer
+    formula: "ceil(sumCopies(max(1, copy.fields.strain), copy.type == 'cyberware'))"
+
+  # Mage Effort: the better of Int or Wis plus Cast, at least 1. Committed Effort is tracked by
+  # how long it is Committed.
+  effort.mage.max:
+    type: integer
+    formula: >-
+      magic.mage ? max(1, max(attributes.int.mod, attributes.wis.mod) + skills.cast.level
+        - magic.cyberPenalty) : 0
+  effort.mage.scene: { type: integer, input: true, default: 0, min: 0 }
+  effort.mage.day: { type: integer, input: true, default: 0, min: 0 }
+  effort.mage.current:
+    type: integer
+    formula: max(0, effort.mage.max - effort.mage.scene - effort.mage.day)
+  # Spells a mage can have prepared: half their level, rounded up, plus Cast.
+  spells.preparedMax:
+    type: integer
+    formula: 'magic.mage ? max(0, ceil(level / 2) + skills.cast.level) : 0'
+  spells.prepared:
+    type: integer
+    formula: "countCopies(copy.type == 'spell' && copy.state.prepared)"
+    limits: { max: spells.preparedMax }
+
+  # Summoner Effort: the better of Con or Cha plus Summon, at least 1.
+  effort.summoner.max:
+    type: integer
+    formula: >-
+      magic.summoner ? max(1, max(attributes.con.mod, attributes.cha.mod) + skills.summon.level
+        - magic.cyberPenalty) : 0
+  effort.summoner.scene: { type: integer, input: true, default: 0, min: 0 }
+  effort.summoner.day: { type: integer, input: true, default: 0, min: 0 }
+  effort.summoner.current:
+    type: integer
+    formula: max(0, effort.summoner.max - effort.summoner.scene - effort.summoner.day)
+
+  # Graced art points: 2 at 1st level and more as the character rises, less the cyber penalty.
+  arts.points:
+    type: integer
+    formula: >-
+      magic.graced ? max(0, [2, 3, 4, 6, 6, 7, 7, 9, 10, 11][level - 1]
+        - (countCopies(copy.type == 'cyberware') > 0 ? magic.cyberPenalty : 0)) : 0
+  arts.spent:
+    type: integer
+    formula: "sumCopies(copy.fields.cost, copy.type == 'art')"
+    limits: { max: arts.points }
+  # Martial Instinct's bonus combat rolls: as many as the highest combat skill, at least one,
+  # refreshed by a night's rest.
+  arts.bonusRolls.max: { type: integer, formula: 0 }
+  arts.bonusRolls.used:
+    { type: integer, input: true, default: 0, min: 0, max: 'max(0, arts.bonusRolls.max)' }
+
+situational:
+  # One of Martial Instinct's bonus rolls, spent on the attack's hit or damage roll.
+  - id: bonusRoll
+    type: enum
+    values: [none, hit, damage]
+    default: none
+    rolls: [attack, damage]
+  # The save resists a spell or magical effect (Occult Pavis).
+  - id: versusMagic
+    type: boolean
+    default: false
+    rolls: [save]
+
+resultBands:
+  overcast:
+    - { id: death, when: roll.total <= 1 }
+    - { id: mortal, when: roll.total <= 4 }
+    - { id: unconscious, when: roll.total <= 8 }
+    - { id: stunned, when: roll.total <= 15 }
+    - { id: dazed, when: roll.total <= 19 }
+    - { id: strained, when: true }
+
+actions:
+  # Cast a prepared spell: Commit its Effort, or overcast it for none and roll on the overcasting
+  # table (d20 + Cast + Con, -2 for a day spell) for its System Strain and worse.
+  - id: cast-spell
+    tags: [magic, spell]
+    available: magic.mage && self.prepared
+    params:
+      # For spells Committing for the scene or the day.
+      commit: { type: enum, values: [scene, day], optional: true }
+      overcast: { type: boolean, default: false }
+    results: [cast, overcast]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              commit: >-
+                item.effort == 'either' ? (has(params.commit) ? params.commit : 'scene')
+                  : item.effort
+      - id: effort
+        kind: changes
+        when: "!params.overcast && flags.commit != 'none'"
+        changes:
+          - { type: adjust, when: "flags.commit == 'scene'", field: effort.mage.scene, by: 1 }
+          - { type: adjust, when: "flags.commit == 'day'", field: effort.mage.day, by: 1 }
+      - id: overcasting
+        kind: roll
+        when: params.overcast
+        tags: [overcast]
+        bands: overcast
+        parts:
+          - dice: 1d20
+          - field: "'skills.cast.level'"
+          - field: "'attributes.con.mod'"
+          - { value: -2, when: "flags.commit == 'day'" }
+      - id: strain
+        kind: changes
+        when: params.overcast
+        changes:
+          - type: adjust
+            when: "!(steps.overcasting.band in ['death', 'mortal'])"
+            field: strain.temporary
+            by: "steps.overcasting.band == 'unconscious' ? 4 : steps.overcasting.band == 'stunned' ? 2 : 1"
+          - type: set
+            when: steps.overcasting.band == 'mortal'
+            field: hp.current
+            value: 0
+      - id: result
+        kind: outcome
+        result: "params.overcast ? 'overcast' : 'cast'"
+        data:
+          consequence: "params.overcast ? steps.overcasting.band : 'none'"
+
+  # Summon a spirit: Commit Summoner Effort for the day, its cost.
+  - id: summon-spirit
+    tags: [magic, summoning]
+    available: magic.summoner
+    params:
+      # Immediate summonings already made this scene, each adding one point.
+      earlier: { type: integer, default: 0, min: 0 }
+    results: [summoned]
+    steps:
+      - id: commit
+        kind: changes
+        changes:
+          - type: adjust
+            field: effort.summoner.day
+            by: 'self.cost + (self.ritual ? 0 : params.earlier)'
+      - { id: result, kind: outcome, result: "'summoned'" }

package/rules/skills.yaml

@@ -0,0 +1,61 @@
+families:
+  skill:
+    [
+      administer,
+      connect,
+      drive,
+      exert,
+      fix,
+      heal,
+      know,
+      lead,
+      notice,
+      perform,
+      program,
+      punch,
+      shoot,
+      sneak,
+      stab,
+      survive,
+      talk,
+      trade,
+      work,
+      cast,
+      summon,
+    ]
+
+fields:
+  # The level the character has trained, -1 for no skill at all, up to level-4. Creation and
+  # advancement raise it; nothing else does.
+  'skills.{skill}.base':
+    type: integer
+    input: true
+    default: -1
+    min: -1
+    max: 4
+    tags: [skill-base, 'skill.{skill}']
+  # Skill points banked toward the skill's next level: a Focus's bonus skill taken during
+  # advancement counts as three points, and what doesn't buy a level stays here.
+  'skills.{skill}.credit': { type: integer, input: true, default: 0, min: 0, max: 4 }
+  # The level checks use: the trained level, or a skillplug's if that is higher.
+  'skills.{skill}.level':
+    { type: integer, formula: 'skills.{skill}.base', tags: [skill, 'skill.{skill}'] }
+
+  # Work names a profession.
+  skills.work.profession: { type: string, input: true, default: '' }
+
+# Names for a skill's level, for showing it ("Level-1", or "No skill" for -1).
+resultBands:
+  skill-level:
+    - { id: untrained, when: roll.total < 0 }
+    - { id: level-0, when: roll.total == 0 }
+    - { id: level-1, when: roll.total == 1 }
+    - { id: level-2, when: roll.total == 2 }
+    - { id: level-3, when: roll.total == 3 }
+    - { id: level-4, when: true }
+
+constraints:
+  # No character begins play with a skill above level-1.
+  - id: creation-skill-cap
+    check: >-
+      !character.creating || maxList(keysOf('skill'), fieldOf('skills.{skill}.base', x)) <= 1

package/rules/tags.yaml

@@ -0,0 +1,137 @@
+tags:
+  # Fields
+  - attribute
+  - attribute-base
+  - attribute-score-mod
+  - attribute-mod
+  - attribute-mod-bonus
+  - attribute-mod-cap
+  - attr.str
+  - attr.dex
+  - attr.con
+  - attr.int
+  - attr.wis
+  - attr.cha
+  - skill-base
+  - skill.administer
+  - skill.connect
+  - skill.drive
+  - skill.exert
+  - skill.fix
+  - skill.heal
+  - skill.know
+  - skill.lead
+  - skill.notice
+  - skill.perform
+  - skill.program
+  - skill.punch
+  - skill.shoot
+  - skill.sneak
+  - skill.stab
+  - skill.survive
+  - skill.talk
+  - skill.trade
+  - skill.work
+  - skill.cast
+  - skill.summon
+  - save.physical
+  - save.evasion
+  - save.mental
+  - save.luck
+
+  # Rolls and steps
+  - check
+  - skill-check
+  - skill-dice
+  - attack.melee
+  - attack.ranged
+  - attack.attribute
+  - attack.skill
+  - attack.burst
+  - damage.melee
+  - damage.ranged
+  - damage.attribute
+  - damage.burst
+  - damage.punch
+  - damage.skill
+  - trauma
+  - initiative
+  - hit-points
+  - healing
+  - first-aid
+  - major-injury
+  - overcast
+  - creation
+  # Steps an add-on pack's rules effects reach.
+  - creation.item
+  - creation.gear
+  - creation.finish
+  - building
+  - advancement
+  - advancement.level
+  - skill-pick
+  - focus-pick
+  - edge-pick
+  - reload
+  - drug
+  - cyber
+  - hacking
+  - magic
+  - spell
+  - summoning
+  - rest
+  - rest.night
+  - rest.scene
+  - injury
+  - armor.heavy
+
+  # Incoming damage
+  - damage.weapon
+  - damage.nonlethal
+  - damage.traumatic
+  - damage.cyberspace
+  - damage.direct
+
+  # Content
+  - standard
+  - repeatable
+  - asks-attribute
+  - brings-cyber
+  - bars-cyber
+  - not-underdog
+  - retroactive-points
+  - restricted
+  - worn
+  - vr-crown
+  - firearm
+  - melee
+  - unarmed
+  - thrown
+  - grenade
+  - heavy
+  - implant
+  - burst
+  - suppress
+  - braced
+  - quick-reload
+  - two-handed
+  - nonlethal
+  - anti-vehicle
+  - launcher
+  - indirect
+  - trap
+  - special
+  - vehicle-mounted
+  - body-blades
+  - blade
+  - cranial-jack
+  - gunlink
+  - cybereyes
+  - cyberears
+  - dermal-armor
+  - self-terminating
+  - portable
+  - flying
+  - armored
+  - armored-heavy
+  - alacrity

package/rules/vehicles.yaml

@@ -0,0 +1,30 @@
+contentTypes:
+  # Vehicles. Fittings and mods are templates that add to the copy's fields; fittings use Power
+  # and Mass, and the vehicle must have enough of both.
+  vehicle:
+    carried: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      speed: { type: integer, required: true }
+      # Armor rating, subtracted from damage. Vehicles tagged `armored` are immune to weapons
+      # short of heavy ones or those that can make Traumatic Hits on vehicles.
+      armor: { type: integer, default: 0, min: 0 }
+      traumaTarget: { type: integer, required: true }
+      ac: { type: integer, required: true }
+      hp: { type: integer, required: true, min: 1 }
+      crew: { type: integer, required: true, min: 1 }
+      power: { type: integer, required: true, min: 0 }
+      mass: { type: integer, required: true, min: 0 }
+      powerUsed: { type: integer, default: 0, min: 0 }
+      massUsed: { type: integer, default: 0, min: 0 }
+      size: { type: enum, values: [small, medium, large], required: true }
+      hardpoints: { type: integer, default: 0, min: 0 }
+    state:
+      hp: { type: integer, default: item.hp, min: 0, max: item.hp }
+      # Bought with an Ace Driver's or Roamer's gear budget.
+      focusGear: { type: boolean, default: false }
+
+constraints:
+  - id: vehicle-power-mass
+    copies: { type: vehicle }
+    check: item.powerUsed <= item.power && item.massUsed <= item.mass

package/rules/weapons.yaml

@@ -0,0 +1,253 @@
+contentTypes:
+  # Weapons. A Readied weapon is `equipped`. Firearms track the rounds left in the magazine.
+  weapon:
+    carried: true
+    equippable: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      enc: { type: integer, min: 0 }
+      damage: { type: dice, required: true }
+      # The combat skill: `shoot`, `stab` or `punch`. Thrown weapons may also use Exert or Stab.
+      skill: { type: enum, values: [shoot, stab, punch], required: true, open: true }
+      # The attribute that modifies hit and damage: the better of two where two are listed.
+      attribute: { type: enum, values: [str, dex, str-dex, wis, none], required: true }
+      rangeNormal: { type: integer, min: 0 }
+      rangeLong: { type: integer, min: 0 }
+      magazine: { type: integer, min: 1 }
+      # Shock: damage on a miss against a target whose Melee AC is at most `shockAc` (any AC when
+      # it has none).
+      shockDamage: { type: integer, min: 0 }
+      shockAc: { type: integer, min: 0 }
+      traumaDie: { type: dice }
+      traumaRating: { type: integer, min: 1 }
+      # Bonuses mods add.
+      attackBonus: { type: integer, default: 0 }
+      damageBonus: { type: integer, default: 0 }
+      shockBonus: { type: integer, default: 0 }
+      traumaDieBonus: { type: integer, default: 0 }
+    state:
+      loaded:
+        type: integer
+        default: 'has(item.magazine) ? item.magazine : 0'
+        min: 0
+        max: 'has(item.magazine) ? item.magazine : 0'
+    actions:
+      - use: attack
+      - use: reload
+
+  # The unarmed attack every character has.
+standardCopies:
+  - { type: weapon, where: "'standard' in item.tags" }
+
+fields:
+  # The highest Melee AC melee Shock treats a target as having: Armsmaster 2, Close Combatant 2
+  # and Shocking Assault treat every target as AC 10.
+  combat.shockAc: { type: integer, formula: '99' }
+  # A bonus to melee and unarmed Shock (Shocking Assault 2).
+  combat.shockBonus: { type: integer, formula: '0' }
+  # A combat skill added to damage: Stab to melee and thrown weapons and their Shock
+  # (Armsmaster), Shoot to ranged weapons (Deadeye). A thrown weapon takes the better one.
+  combat.meleeSkillDamage: { type: integer, formula: '0' }
+  combat.rangedSkillDamage: { type: integer, formula: '0' }
+  # A bonus to hit with melee and thrown weapons, not unarmed attacks (Armsmaster 2).
+  combat.meleeHitBonus: { type: integer, formula: '0' }
+
+resultBands:
+  hit:
+    - { id: hit, when: roll.total >= flags.ac, success: true }
+    - { id: miss, when: true }
+  trauma:
+    - { id: traumatic, when: roll.total >= flags.traumaTarget }
+    - { id: none, when: true }
+
+actions:
+  # Attack with a weapon: 1d20 + attack bonus + the attribute modifier + the combat skill (-2
+  # with no skill) against the target's Ranged or Melee AC. A hit rolls damage and the Trauma
+  # Die; a Traumatic Hit multiplies the damage by the Trauma Rating. A melee miss may still deal
+  # Shock. Burst fire spends three rounds for +2 to hit and damage.
+  - id: attack
+    tags: [attack]
+    available: >-
+      (self.equipped || 'standard' in item.tags || 'implant' in item.tags)
+        && !('trap' in item.tags) && (!has(item.magazine) || self.loaded >= 1)
+    params:
+      attribute: { type: enum, values: [str, dex, wis], optional: true }
+      thrown: { type: boolean, default: false }
+      burst: { type: boolean, default: false }
+      lethal: { type: boolean, optional: true }
+      targetAc: { type: integer, optional: true }
+      targetTrauma: { type: integer, optional: true }
+      modifier: { type: integer, optional: true }
+    participants:
+      target:
+        max: 1
+        fields:
+          ac.ranged: { type: integer }
+          ac.melee: { type: integer }
+          trauma.target: { type: integer, default: 6 }
+    results: [hit, miss, rolled]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              ranged: >-
+                has(item.rangeNormal) && (!('melee' in item.tags) || params.thrown)
+              thrown: >-
+                'thrown' in item.tags
+                  || (params.thrown && has(item.rangeNormal) && 'melee' in item.tags)
+              attributes: >-
+                item.attribute == 'str-dex' ? ['str', 'dex']
+                  : item.attribute == 'none' ? [] : [item.attribute]
+              burst: params.burst && 'burst' in item.tags && self.loaded >= 3
+              nonlethal: "has(params.lethal) ? !params.lethal : 'nonlethal' in item.tags"
+      - id: pick
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              attribute: >-
+                has(params.attribute) && params.attribute in flags.attributes ? params.attribute
+                  : size(flags.attributes) == 0 ? ''
+                  : sortList(flags.attributes, -fieldOf('attributes.{attribute}.mod', x))[0]
+              skill: >-
+                flags.thrown ? max(skills.shoot.level, skills.stab.level, skills.exert.level)
+                  : fieldOf('skills.{skill}.level', item.skill)
+              ac: >-
+                'grenade' in item.tags ? 10
+                  : size(participants.target) > 0
+                  ? (flags.ranged ? participants.target[0].ac.ranged
+                    : participants.target[0].ac.melee)
+                  : has(params.targetAc) ? params.targetAc : -1
+              meleeAc: >-
+                size(participants.target) > 0 ? participants.target[0].ac.melee
+                  : has(params.targetAc) ? params.targetAc : -1
+              traumaTarget: >-
+                size(participants.target) > 0 ? participants.target[0].trauma.target
+                  : has(params.targetTrauma) ? params.targetTrauma : 6
+      - id: mod
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              attrMod: "flags.attribute == '' ? 0 : fieldOf('attributes.{attribute}.mod', flags.attribute)"
+              # Armsmaster and Deadeye: a skill's level to damage (and Armsmaster's to Shock).
+              skillDamage: >-
+                'unarmed' in item.tags ? 0
+                  : flags.thrown ? max(combat.meleeSkillDamage, combat.rangedSkillDamage)
+                  : flags.ranged ? combat.rangedSkillDamage : combat.meleeSkillDamage
+              meleeHit: >-
+                !('unarmed' in item.tags) && (!flags.ranged || flags.thrown)
+                  ? combat.meleeHitBonus : 0
+      - id: hit
+        kind: roll
+        tags:
+          - attack
+          - { formula: "flags.ranged ? 'attack.ranged' : 'attack.melee'" }
+          - { formula: "'skill.' + item.skill" }
+        bands: hit
+        parts:
+          - dice: 1d20
+          - field: "'combat.attackBonus'"
+          - { value: flags.attrMod, tags: [attack.attribute] }
+          - { value: 'flags.skill >= 0 ? flags.skill : -2', tags: [attack.skill] }
+          - { value: item.attackBonus, when: item.attackBonus != 0 }
+          - { value: flags.meleeHit, when: flags.meleeHit != 0 }
+          - { value: 2, when: flags.burst, tags: [attack.burst] }
+          - { value: params.modifier, when: has(params.modifier) }
+      - id: landed
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              hit: flags.ac < 0 || steps.hit.band == 'hit'
+              shock: >-
+                has(item.shockDamage) && item.shockDamage > 0 && !flags.ranged
+                  && (!has(item.shockAc) || flags.meleeAc < 0
+                    || min(flags.meleeAc, combat.shockAc) <= item.shockAc)
+                  ? max(0, item.shockDamage + flags.attrMod + item.shockBonus
+                    + combat.shockBonus + combat.damageBonus + flags.skillDamage)
+                  : 0
+      - id: damage
+        kind: roll
+        when: flags.hit
+        tags:
+          - damage
+          - { formula: "flags.ranged ? 'damage.ranged' : 'damage.melee'" }
+          - { formula: "'skill.' + item.skill" }
+        parts:
+          - dice: item.damage
+          - { value: flags.attrMod, tags: [damage.attribute] }
+          - { value: 2, when: flags.burst, tags: [damage.burst] }
+          - { value: item.damageBonus, when: item.damageBonus != 0 }
+          - { value: flags.skillDamage, when: flags.skillDamage != 0, tags: [damage.skill] }
+          - { field: "'combat.damageBonus'" }
+          - value: skills.punch.level
+            when: "'unarmed' in item.tags && skills.punch.level > 0"
+            tags: [damage.punch]
+      - id: trauma
+        kind: roll
+        when: flags.hit && has(item.traumaDie) && !flags.nonlethal
+        tags: [trauma]
+        bands: trauma
+        parts:
+          - dice: item.traumaDie
+          - { value: item.traumaDieBonus, when: item.traumaDieBonus != 0 }
+          - { field: "'combat.traumaBonus'" }
+      - id: total
+        kind: branch
+        cases:
+          - when: flags.hit
+            flags:
+              traumatic: has(steps.trauma) && steps.trauma.band == 'traumatic'
+              dealt: >-
+                max(0, max(steps.damage.total, flags.shock))
+                  * (has(steps.trauma) && steps.trauma.band == 'traumatic' ? item.traumaRating : 1)
+          - when: true
+            flags: { traumatic: false, dealt: flags.shock }
+      # Martial Instinct: the bonus roll is spent once the roll it doubles is made.
+      - id: bonusRoll
+        kind: changes
+        when: >-
+          situational.bonusRoll != 'none' && arts.bonusRolls.used < arts.bonusRolls.max
+            && (situational.bonusRoll == 'hit' || flags.hit)
+        changes:
+          - { type: adjust, field: arts.bonusRolls.used, by: 1 }
+      - id: ammo
+        kind: changes
+        when: has(item.magazine)
+        changes:
+          - { type: adjustState, entry: self, key: loaded, by: 'flags.burst ? -3 : -1' }
+      - id: deal
+        kind: changes
+        when: flags.dealt > 0
+        to: target
+        changes:
+          - type: adjust
+            field: hp.current
+            by: -flags.dealt
+            tags:
+              - damage
+              - damage.weapon
+              - { formula: "flags.nonlethal ? ['damage.nonlethal'] : []" }
+              - { formula: "flags.traumatic ? ['damage.traumatic'] : []" }
+      - id: result
+        kind: outcome
+        result: "flags.ac < 0 ? 'rolled' : flags.hit ? 'hit' : 'miss'"
+        data:
+          damage: flags.dealt
+          traumatic: flags.traumatic
+          shock: flags.shock
+
+  # Reload a firearm: fill its magazine.
+  - id: reload
+    tags: [reload]
+    available: has(item.magazine) && self.loaded < item.magazine
+    results: [reloaded]
+    steps:
+      - id: fill
+        kind: changes
+        changes:
+          - { type: setState, entry: self, key: loaded, value: item.magazine }
+      - { id: result, kind: outcome, result: "'reloaded'" }