@opencharacter/wwn-srd 0.0.0-stage → 0.2.0

package/pack.yaml

@@ -0,0 +1,12 @@
+id: wwn-srd
+version: 0.2.0
+specVersion: 0.3.0
+license: CC0-1.0
+notices:
+  not-affiliated: >-
+    This pack is compatible with Worlds Without Number, a game by Sine Nomine Publishing. It is
+    an unofficial work built from the game's System Reference Document, which Sine Nomine
+    Publishing dedicates to the public domain under CC0; it is not an official Sine Nomine
+    Publishing product, and it is not affiliated with, licensed by or endorsed by Sine Nomine
+    Publishing.
+defaultLanguage: en

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@opencharacter/wwn-srd",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Open Character Format pack for the character rules of the Worlds Without Number SRD (CC0). Unofficial.",
+  "keywords": [
+    "character-sheet",
+    "content-pack",
+    "fantasy",
+    "ocf",
+    "open-character-format",
+    "rpg",
+    "tabletop",
+    "ttrpg",
+    "worlds-without-number"
+  ],
+  "homepage": "https://opencharacterformat.org",
+  "bugs": {
+    "url": "https://github.com/pixelqueue/opencharacter/issues"
+  },
+  "license": "CC0-1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pixelqueue/opencharacter.git",
+    "directory": "packs/wwn/srd"
+  },
+  "files": [
+    "dist",
+    "pack.yaml",
+    "rules",
+    "content",
+    "i18n",
+    "upgrades",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/release.json"
+    },
+    "./release.json": "./dist/release.json",
+    "./i18n/*": {
+      "types": "./dist/i18n/*.d.ts",
+      "import": "./dist/i18n/*.js",
+      "default": "./dist/i18n/*.json"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@opencharacter/engine": "0.3.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {}
 }

package/rules/advancement.yaml

@@ -0,0 +1,186 @@
+fields:
+  xp.current: { type: integer, input: true, default: 0, min: 0 }
+  # The book's two paces: fast or slow leveling.
+  xp.pace: { type: enum, values: [fast, slow], input: true, default: fast }
+  xp.nextLevel:
+    type: integer
+    formula: >-
+      level >= 10 ? 0
+        : xp.pace == 'fast' ? [3, 6, 12, 18, 27, 39, 54, 72, 93][level - 1]
+        : [6, 15, 24, 36, 51, 69, 87, 105, 139][level - 1]
+  xp.levelUp: { type: boolean, formula: 'xp.nextLevel > 0 && xp.current >= xp.nextLevel' }
+
+followUps:
+  - id: level-up
+    while: '!character.creating && xp.levelUp'
+    action: level-up
+
+actions:
+  # A new level: hit dice rolled again (at least one more than before), three skill points (four
+  # for an Expert), a Focus at levels 2, 5, 7 and 10, the arts the tradition grants, and new
+  # spells. Saves and attack bonus follow the level.
+  - id: level-up
+    tags: [advancement]
+    available: '!character.creating && level < 10 && xp.levelUp'
+    params:
+      random: { type: boolean, default: false }
+    results: [advanced]
+    steps:
+      - id: before
+        kind: branch
+        cases:
+          - when: true
+            flags: { oldMax: hp.max, oldRolled: hp.rolled }
+      - id: gain
+        tags: [advancement.level]
+        kind: changes
+        changes:
+          - { type: adjust, field: level, by: 1 }
+          - { type: adjust, field: skillPoints.unspent, by: 3 }
+          - { type: adjust, when: class.expert > 0, field: skillPoints.expert, by: 1 }
+      # Each die adds the class's bonus and the Constitution modifier.
+      - id: hitDice
+        kind: roll
+        sheet: proposed
+        tags: [advancement]
+        parts:
+          # No die gives less than 1.
+          - dice: >-
+              hp.dieBonus + attributes.con.mod >= 0 ? (level)d6
+                : hp.dieBonus + attributes.con.mod == -1 ? (level)d6min2
+                : hp.dieBonus + attributes.con.mod == -2 ? (level)d6min3
+                : (level)d6min4
+          - value: level * (hp.dieBonus + attributes.con.mod)
+      - id: hp
+        kind: changes
+        changes:
+          - type: set
+            field: hp.rolled
+            value: max(steps.hitDice.total, flags.oldRolled + 1)
+      # A Focus gained now puts three skill points toward its bonus skill.
+      - id: focus
+        kind: action
+        sheet: proposed
+        when: level in [2, 5, 7, 10]
+        use: pick-focus
+        params:
+          kind: "'any'"
+          random: params.random
+          points: 3
+      - id: arts
+        kind: action
+        use: pick-arts
+        params: { random: params.random }
+      # New spells: two for a High Mage, one for another caster. Two partial casting traditions
+      # pick one of them to learn from.
+      - id: spellTradition
+        kind: choice
+        sheet: proposed
+        random: params.random
+        options:
+          values: { formula: "keysOf('spellTrad') + ['invoker']" }
+          where: "fieldOf('tradition.{trad}.tier', value) > 0"
+        recommend: options[0]
+      - id: newSpells
+        kind: choice
+        sheet: proposed
+        when: has(steps.spellTradition)
+        random: params.random
+        repeat:
+          max: >-
+            steps.spellTradition.picked == 'highmage'
+              || (steps.spellTradition.picked == 'invoker' && tradition.invoker.tier == 2) ? 2 : 1
+          min: >-
+            steps.spellTradition.picked == 'highmage'
+              || (steps.spellTradition.picked == 'invoker' && tradition.invoker.tier == 2) ? 2 : 1
+        options:
+          content:
+            type: spell
+            where: >-
+              item.level <= spells.maxLevel && countCopies(copy.item == item.id) == 0
+                && (item.list == 'high' || item.list == steps.spellTradition.picked
+                  || (steps.spellTradition.picked == 'invoker' && invoker.education == item.list))
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      # Current hit points rise with the maximum (Die Hard taken now included).
+      - id: current
+        kind: changes
+        sheet: proposed
+        changes:
+          - type: adjust
+            when: hp.max > flags.oldMax
+            field: hp.current
+            by: hp.max - flags.oldMax
+      - id: result
+        kind: outcome
+        result: "'advanced'"
+
+  # Spend skill points: a skill's next level costs one more than that level (less any credit),
+  # needing character level 3, 6 and 9 for levels 2, 3 and 4; an attribute boost costs one
+  # more than the boosts before it, five at most, needing levels 2, 2, 3, 6 and 9. An Expert's
+  # extra points go to non-combat skills and attributes only, and are spent first there.
+  - id: improve
+    tags: [advancement]
+    available: '!character.creating && skillPoints.unspent + skillPoints.expert > 0'
+    results: [improved]
+    steps:
+      - id: pick
+        kind: choice
+        # A combat skill takes no Expert points.
+        options:
+          values: { formula: "keysOf('skill') + keysOf('attr')" }
+          where: >-
+            value in keysOf('attr')
+              ? attributes.boosts < 5 && fieldOf('attributes.{attr}.score', value) < 18
+                && level >= [1, 1, 3, 6, 9][attributes.boosts]
+                && attributes.boosts + 1 <= skillPoints.unspent + skillPoints.expert
+              : fieldOf('skills.{skill}', value) < 4
+                && level >= [1, 1, 3, 6, 9][fieldOf('skills.{skill}', value) + 1]
+                && fieldOf('skills.{skill}', value) + 2 - fieldOf('skillCredit.{skill}', value)
+                  <= skillPoints.unspent
+                    + (value in ['punch', 'shoot', 'stab'] ? 0 : skillPoints.expert)
+        recommend: options[0]
+      - id: cost
+        kind: branch
+        cases:
+          - when: "steps.pick.picked in keysOf('attr')"
+            flags:
+              attribute: true
+              cost: attributes.boosts + 1
+              expert: min(skillPoints.expert, attributes.boosts + 1)
+          - when: true
+            flags:
+              attribute: false
+              cost: >-
+                fieldOf('skills.{skill}', steps.pick.picked) + 2
+                  - fieldOf('skillCredit.{skill}', steps.pick.picked)
+              expert: >-
+                steps.pick.picked in ['punch', 'shoot', 'stab'] ? 0
+                  : min(skillPoints.expert, fieldOf('skills.{skill}', steps.pick.picked) + 2
+                    - fieldOf('skillCredit.{skill}', steps.pick.picked))
+      - id: pay
+        kind: changes
+        changes:
+          - type: adjust
+            when: flags.attribute
+            field: { formula: "'attributes.' + steps.pick.picked + '.score'" }
+            by: 1
+          - { type: adjust, when: flags.attribute, field: attributes.boosts, by: 1 }
+          - type: adjust
+            when: '!flags.attribute'
+            field: { formula: "fieldId('skills.{skill}', steps.pick.picked)" }
+            by: 1
+          - type: set
+            when: '!flags.attribute'
+            field: { formula: "fieldId('skillCredit.{skill}', steps.pick.picked)" }
+            value: 0
+          - { type: adjust, when: flags.expert > 0, field: skillPoints.expert, by: -flags.expert }
+          - type: adjust
+            when: flags.cost - flags.expert > 0
+            field: skillPoints.unspent
+            by: -(flags.cost - flags.expert)
+      - id: result
+        kind: outcome
+        result: "'improved'"

package/rules/attributes.yaml

@@ -0,0 +1,30 @@
+families:
+  attr: [str, dex, con, int, wis, cha]
+
+fields:
+  'attributes.{attr}.score':
+    type: integer
+    input: true
+    default: 10
+    min: 3
+    max: 18
+    tags: [attribute, 'attr.{attr}']
+  # Bonuses and penalties to the modifier, not the score. They keep it within -2 and +2, or +3
+  # where a Focus says so (Developed Attribute, Xenoblooded).
+  'attributes.{attr}.modBonus': { type: integer, formula: 0, tags: [mod-bonus, 'attr.{attr}'] }
+  'attributes.{attr}.modCap': { type: integer, formula: 2, tags: [mod-cap, 'attr.{attr}'] }
+  'attributes.{attr}.mod':
+    type: integer
+    tags: [attribute-mod]
+    formula: >-
+      max(-2, min(attributes.{attr}.modCap, (attributes.{attr}.score <= 3 ? -2
+        : attributes.{attr}.score <= 7 ? -1 : attributes.{attr}.score <= 13 ? 0
+        : attributes.{attr}.score <= 17 ? 1 : 2) + attributes.{attr}.modBonus))
+
+  # Attribute boosts bought with skill points as the character advances (five at most).
+  attributes.boosts: { type: integer, input: true, default: 0, min: 0, max: 5 }
+  attributes.bestMod:
+    type: integer
+    formula: >-
+      max(attributes.str.mod, attributes.dex.mod, attributes.con.mod, attributes.int.mod,
+        attributes.wis.mod, attributes.cha.mod)

package/rules/backgrounds.yaml

@@ -0,0 +1,60 @@
+families:
+  backgroundEntry:
+    [
+      freeSkill,
+      growth1,
+      growth2,
+      growth3,
+      growth4,
+      growth5,
+      growth6,
+      learning1,
+      learning2,
+      learning3,
+      learning4,
+      learning5,
+      learning6,
+      learning7,
+      learning8,
+    ]
+
+contentTypes:
+  # A background's free skill and its Growth (d6) and Learning (d8) tables. Each entry is a
+  # skill, `any` (any skill), `combat` (Stab, Shoot or Punch), or attribute points: `any-stat`
+  # (+1 to any), `physical` or `mental` (+2 to one or +1 to two of them).
+  background:
+    copies: { max: 1 }
+    fields:
+      '{backgroundEntry}':
+        type: enum
+        open: true
+        values:
+          [
+            administer,
+            connect,
+            convince,
+            craft,
+            exert,
+            heal,
+            know,
+            lead,
+            magic,
+            notice,
+            perform,
+            pray,
+            punch,
+            ride,
+            sail,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            trade,
+            work,
+            any,
+            combat,
+            any-stat,
+            physical,
+            mental,
+          ]
+        required: true

package/rules/classes.yaml

@@ -0,0 +1,77 @@
+fields:
+  level: { type: integer, input: true, default: 1, min: 1, max: 10 }
+
+  # Each class's perks: 2 for the full class, 1 for a partial one. A Warrior's or an Expert's
+  # brings a Focus pick, an Expert's an extra skill point each level. A Mage's tradition counts
+  # in `tradition.<key>.tier` (magic.yaml); `class.mage` counts the Mage classes held.
+  class.warrior: { type: integer, formula: 0 }
+  class.expert: { type: integer, formula: 0 }
+  class.mage: { type: integer, formula: 0 }
+
+  # The class mix's hit dice and attack bonus. Some partial classes count as Warriors or Experts
+  # here without their perks (the Bard, the Wise, the Mageslayer); the Duelist's fragility
+  # takes the Warrior's +2 away.
+  chassis.attackFull: { type: integer, formula: 0 }
+  chassis.attackWarrior: { type: integer, formula: 0 }
+  chassis.attackExpert: { type: integer, formula: 0 }
+  chassis.hitsWarrior: { type: integer, formula: 0 }
+  chassis.hitsExpert: { type: integer, formula: 0 }
+  chassis.fragile: { type: integer, formula: 0 }
+
+  # Each hit die is 1d6 plus this: +2 with a Warrior, +0 with an Expert, -1 otherwise.
+  # Martial Style keeps it at least +0.
+  hp.dieBonus:
+    type: integer
+    formula: >-
+      chassis.hitsWarrior > 0 && chassis.fragile == 0 ? 2
+        : chassis.hitsWarrior > 0 || chassis.hitsExpert > 0 ? 0
+        : -1
+
+  attack.base:
+    type: integer
+    formula: >-
+      chassis.attackFull > 0 ? level
+        : chassis.attackWarrior > 0 ? [1, 2, 2, 3, 4, 5, 5, 6, 6, 7][level - 1]
+        : chassis.attackExpert > 0 ? floor(level / 2)
+        : floor(level / 5)
+
+  # Focus levels: one of any kind, one combat Focus with a Warrior, one non-combat Focus with an
+  # Expert, and one more at levels 2, 5, 7 and 10.
+  foci.allowed:
+    type: integer
+    formula: >-
+      1 + (class.warrior > 0 ? 1 : 0) + (class.expert > 0 ? 1 : 0)
+        + (level >= 2 ? 1 : 0) + (level >= 5 ? 1 : 0) + (level >= 7 ? 1 : 0)
+        + (level >= 10 ? 1 : 0)
+  foci.taken:
+    type: integer
+    formula: "sumCopies(copy.state.level, copy.type == 'focus')"
+
+  # A Beastmaster's companion's natural hit dice (Feral Toughness adds them to hit points).
+  companion.hitDice: { type: integer, input: true, default: 0, min: 0 }
+
+  # Killing Blow: half the level, rounded up, on every damage roll and Shock.
+  damage.killingBlow: { type: integer, formula: 0 }
+
+contentTypes:
+  class:
+    copies: { max: 1 }
+  # An Adventurer's two halves.
+  partial:
+    grantOnly: true
+    copies: { max: 0 }
+
+constraints:
+  - id: creation-class
+    check: "!character.creating || countCopies(copy.type == 'class') > 0"
+  - id: foci-allowed
+    check: foci.taken <= foci.allowed
+    data: { allowed: foci.allowed }
+  # No Mage class pairs with the Mageslayer.
+  - id: mageslayer-pairing
+    check: tradition.mageslayer.tier == 0 || class.mage == 0
+  # A partial Invoker doesn't pair with another partial spellcasting class.
+  - id: invoker-pairing
+    check: >-
+      tradition.invoker.tier != 1
+        || tradition.highmage.tier + tradition.elementalist.tier + tradition.necromancer.tier == 0

package/rules/combat.yaml

@@ -0,0 +1,241 @@
+fields:
+  # Martial Style: Punch attacks hit no worse than an Expert of the same level.
+  attack.punchBase: { type: integer, formula: attack.base }
+
+  # Body armor worn (the best of it) and a shield carried.
+  armor.wornAc:
+    type: integer
+    formula: "maxCopies(copy.fields.ac, copy.type == 'armor' && copy.equipped && copy.fields.category != 'shield')"
+  # The Encumbrance of the body armor worn, -1 with none.
+  armor.wornEnc:
+    type: integer
+    formula: >-
+      countCopies(copy.type == 'armor' && copy.equipped && copy.fields.category != 'shield') > 0
+        ? maxCopies(copy.fields.enc, copy.type == 'armor' && copy.equipped
+          && copy.fields.category != 'shield')
+        : -1
+  armor.wornHeavy:
+    type: boolean
+    formula: >-
+      countCopies(copy.type == 'armor' && copy.equipped
+        && copy.fields.category in ['medium', 'heavy']) > 0
+  armor.shield:
+    type: boolean
+    formula: "countCopies(copy.type == 'armor' && copy.equipped && copy.fields.category == 'shield') > 0"
+  armor.shieldAc:
+    type: integer
+    formula: "maxCopies(copy.fields.ac, copy.type == 'armor' && copy.equipped && copy.fields.category == 'shield')"
+
+  # Natural defenses that don't stack with armor (Impervious Defense, Unarmored Defense, Cold
+  # Flesh) raise this.
+  ac.innate: { type: integer, formula: 10 }
+  ac.base: { type: integer, formula: 'max(10, armor.wornAc, ac.innate)' }
+  # A shield sets AC to its own, or adds 1 to armor as good or better.
+  ac.withShield:
+    type: integer
+    formula: '!armor.shield ? ac.base : ac.base >= armor.shieldAc ? ac.base + 1 : armor.shieldAc'
+  # Bonuses that can't raise AC above 18 (Pavis of Elements).
+  ac.cappedBonus: { type: integer, formula: 0 }
+  ac.value:
+    type: integer
+    formula: >-
+      ac.withShield + attributes.dex.mod
+        + max(0, min(ac.cappedBonus, 18 - ac.withShield - attributes.dex.mod))
+
+  # Shock bonuses beyond the attribute modifier and Killing Blow (Shocking Assault).
+  shock.bonus: { type: integer, formula: 0 }
+  # Melee weapon Shock, and unarmed Shock, that treats every target as AC 10.
+  shock.ignoresAc: { type: boolean, formula: false }
+  shock.unarmedIgnoresAc: { type: boolean, formula: false }
+
+  # A Duelist's favored weapons and their hit bonus: the Duelist's table, or the level with a
+  # partial Warrior.
+  duelist.favored: { type: set, of: weapon }
+  attack.favoredBase:
+    type: integer
+    formula: >-
+      tradition.duelist.tier == 0 ? attack.base
+        : max(attack.base, class.warrior > 0 ? level : [1, 1, 2, 2, 3, 3, 4, 4, 5, 5][level - 1])
+
+  # Unarmed attacks: the die and Shock that Unarmed Combatant or Unarmed Might give.
+  unarmed.die: { type: dice, formula: 1d2 }
+  unarmed.shock: { type: integer, formula: 0 }
+  unarmed.shockAc: { type: integer, formula: 15 }
+
+contentTypes:
+  weapon:
+    carried: true
+    equippable: true
+    fields:
+      damage: { type: dice, required: true }
+      shock: { type: integer, default: 0, min: 0 }
+      shockAc: { type: integer, default: 0, min: 0 }
+      attribute: { type: enum, values: [str, dex, str-dex], required: true }
+      skill: { type: enum, values: [stab, shoot, punch], required: true, open: true }
+      rangeShort: { type: integer, min: 0 }
+      rangeLong: { type: integer, min: 0 }
+      cost: { type: integer, min: 0 }
+      costUnit: { type: enum, values: [cp, sp], default: sp }
+      enc: { type: integer, default: 1, min: 0 }
+      bundle: { type: integer, default: 1, min: 1 }
+      wornFree: { type: boolean, default: false }
+    actions:
+      - use: attack
+
+  armor:
+    carried: true
+    equippable: true
+    fields:
+      ac: { type: integer, required: true, min: 10 }
+      category: { type: enum, values: [light, medium, heavy, shield], required: true }
+      cost: { type: integer, min: 0 }
+      costUnit: { type: enum, values: [cp, sp], default: sp }
+      enc: { type: integer, default: 1, min: 0 }
+      bundle: { type: integer, default: 1, min: 1 }
+      wornFree: { type: boolean, default: false }
+    effects:
+      # Medium armor's Encumbrance is a penalty to Sneak; heavy armor's to Sneak and Exert.
+      - id: sneak-penalty
+        target: { rolls: [skill.sneak] }
+        op: add
+        value: -item.enc
+        when: "self.equipped && item.category in ['medium', 'heavy'] && item.enc > 0"
+      - id: exert-penalty
+        target: { rolls: [skill.exert] }
+        op: add
+        value: -item.enc
+        when: "self.equipped && item.category == 'heavy' && item.enc > 0"
+
+standardCopies:
+  - { type: weapon, where: "'unarmed' in item.tags" }
+
+resultBands:
+  attack:
+    - { id: hit, when: 'roll.kept[0] == 20' }
+    - { id: miss, when: 'roll.kept[0] == 1' }
+    - { id: rolled, when: flags.ac < 0 }
+    - { id: hit, when: roll.total >= flags.ac, success: true }
+    - { id: miss, when: true }
+
+actions:
+  - id: initiative
+    tags: [combat]
+    results: [rolled]
+    steps:
+      - id: roll
+        kind: roll
+        tags: [initiative]
+        parts:
+          - dice: 1d8
+          - field: "'attributes.dex.mod'"
+      - id: result
+        kind: outcome
+        result: "'rolled'"
+        data:
+          total: steps.roll.total
+
+  # A hit roll of 1d20 plus attack bonus, skill (-2 without it) and the weapon's attribute; on a
+  # hit, damage; on a melee miss, Shock against a target whose AC is no better than the weapon's.
+  - id: attack
+    tags: [attack]
+    available: self.equipped || 'unarmed' in item.tags
+    params:
+      targetAc: { type: integer, optional: true }
+      thrown: { type: boolean, default: false }
+    results: [hit, miss]
+    steps:
+      - id: setup
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              mode: >-
+                params.thrown ? 'thrown' : item.skill == 'shoot' ? 'ranged'
+                  : item.skill == 'punch' ? 'unarmed' : 'melee'
+              skill: >-
+                params.thrown ? max(skills.stab, skills.shoot)
+                  : fieldOf('skills.{skill}', item.skill)
+              attribute: >-
+                item.attribute == 'str-dex'
+                  ? (attributes.str.mod >= attributes.dex.mod ? 'str' : 'dex') : item.attribute
+              ac: 'has(params.targetAc) ? params.targetAc : -1'
+              dice: "'unarmed' in item.tags ? unarmed.die : item.damage"
+              shock: "'unarmed' in item.tags ? unarmed.shock : item.shock"
+              shockAc: "'unarmed' in item.tags ? unarmed.shockAc : item.shockAc"
+      - id: hitRoll
+        kind: roll
+        tags: [attack, { formula: "'attack.' + flags.mode" }]
+        bands: attack
+        parts:
+          - dice: 1d20
+          - field: >-
+              item.skill == 'punch' ? 'attack.punchBase'
+                : !params.thrown && item.id in duelist.favored ? 'attack.favoredBase'
+                : 'attack.base'
+          - value: 'flags.skill >= 0 ? flags.skill : -2'
+          - field: "'attributes.' + flags.attribute + '.mod'"
+      - id: confirm
+        kind: choice
+        when: steps.hitRoll.band == 'rolled'
+        options: [{ id: hit }, { id: miss }]
+      - id: outcome
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              hit: >-
+                steps.hitRoll.band == 'hit'
+                  || (has(steps.confirm) && steps.confirm.picked == 'hit')
+      # What Shock would do; a hit never does less. Thrown and ranged attacks do no Shock.
+      - id: shock
+        kind: roll
+        when: "flags.shock > 0 && flags.mode in ['melee', 'unarmed']"
+        tags: [shock, { formula: "'shock.' + flags.mode" }]
+        parts:
+          - value: flags.shock
+          - field: "'attributes.' + flags.attribute + '.mod'"
+          - field: "'damage.killingBlow'"
+          - field: "'shock.bonus'"
+      - id: shockApplies
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              shockDamage: >-
+                has(steps.shock) && flags.ac >= 0
+                  && (flags.ac <= flags.shockAc
+                    || (flags.mode == 'melee' && shock.ignoresAc)
+                    || (flags.mode == 'unarmed' && shock.unarmedIgnoresAc))
+                  ? max(0, steps.shock.total) : 0
+      - id: damage
+        kind: roll
+        when: flags.hit
+        tags: [damage, { formula: "'damage.' + flags.mode" }]
+        parts:
+          - dice: flags.dice
+            tags: [weapon-die]
+          - field: "'attributes.' + flags.attribute + '.mod'"
+          - value: max(0, skills.punch)
+            when: flags.mode == 'unarmed'
+          - field: "'damage.killingBlow'"
+      - id: totals
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              dealt: >-
+                flags.hit ? max(has(steps.damage) ? steps.damage.total : 0,
+                    flags.ac < 0 && has(steps.shock) ? steps.shock.total : flags.shockDamage, 0)
+                  : flags.shockDamage
+      - id: deal
+        kind: changes
+        when: flags.dealt > 0
+        to: target
+        changes:
+          - { type: adjust, field: hp.current, by: -flags.dealt, tags: [damage] }
+      - id: result
+        kind: outcome
+        result: "flags.hit ? 'hit' : 'miss'"
+        data:
+          total: steps.hitRoll.total
+          damage: flags.dealt