@opencharacter/wwn-srd 0.0.0-stage → 0.2.0

package/rules/magic.yaml

@@ -0,0 +1,471 @@
+families:
+  trad:
+    [
+      highmage,
+      elementalist,
+      necromancer,
+      healer,
+      vowed,
+      accursed,
+      bard,
+      beastmaster,
+      bloodpriest,
+      duelist,
+      mageslayer,
+      skinshifter,
+      thoughtnoble,
+      invoker,
+      wise,
+    ]
+  effortTrad:
+    [
+      highmage,
+      elementalist,
+      necromancer,
+      healer,
+      vowed,
+      accursed,
+      bard,
+      beastmaster,
+      bloodpriest,
+      duelist,
+      mageslayer,
+      skinshifter,
+      thoughtnoble,
+    ]
+  artTrad:
+    [
+      highmage,
+      elementalist,
+      necromancer,
+      healer,
+      vowed,
+      accursed,
+      bard,
+      beastmaster,
+      bloodpriest,
+      duelist,
+      mageslayer,
+      skinshifter,
+      thoughtnoble,
+      wise,
+    ]
+  effortSpan: [scene, day, ongoing]
+  # The traditions whose arts worn armor or a shield stops as it stops spells, and the ones
+  # medium or heavy armor or a large shield stops (the Duelist's).
+  armorTrad: [highmage, elementalist, necromancer, vowed]
+  heavyArmorTrad: [duelist]
+  # The traditions that cast spells from the spell lists (the Invoker aside).
+  spellTrad: [highmage, elementalist, necromancer]
+
+fields:
+  # 2 for a full Mage of the tradition, 1 for a partial one, 0 otherwise: a Mage's or partial
+  # Mage's picked tradition (`tradition` content) counts here, the other partial classes add
+  # theirs. The skill the tradition brings at creation, '' for none.
+  'tradition.{trad}.tier':
+    type: integer
+    tags: [tradition-tier]
+    formula: >-
+      countPicks(pick.type == 'tradition' && pick.fields.key == '{trad}')
+        * (countCopies(copy.type == 'class' && 'full-mage' in copy.tags) > 0 ? 2 : 1)
+  'tradition.{trad}.skill': { type: string, formula: "''" }
+
+  # How the character casts: a full caster, one partial caster, two partial casters, an
+  # Invoker (full or partial), or none.
+  spells.mode:
+    type: enum
+    values: [none, full, partial, dual, invoker, partial-invoker]
+    formula: >-
+      tradition.invoker.tier == 2 ? 'invoker'
+        : tradition.invoker.tier == 1 ? 'partial-invoker'
+        : countList(keysOf('spellTrad'), fieldOf('tradition.{trad}.tier', x) == 2) > 0 ? 'full'
+        : countList(keysOf('spellTrad'), fieldOf('tradition.{trad}.tier', x) == 1) >= 2 ? 'dual'
+        : countList(keysOf('spellTrad'), fieldOf('tradition.{trad}.tier', x) == 1) > 0 ? 'partial'
+        : 'none'
+  spells.maxLevel:
+    type: integer
+    formula: >-
+      spells.mode == 'full' || spells.mode == 'invoker' ? [1, 1, 2, 2, 3, 3, 4, 4, 5, 5][level - 1]
+        : spells.mode == 'partial' || spells.mode == 'partial-invoker'
+          ? [1, 1, 1, 1, 2, 2, 2, 2, 3, 3][level - 1]
+        : spells.mode == 'dual' ? [1, 1, 1, 2, 2, 2, 3, 3, 3, 4][level - 1]
+        : 0
+  # Spells cast a day (an Invoker spends spell points instead).
+  spells.castsPerDay:
+    type: integer
+    formula: >-
+      spells.mode == 'full' ? [1, 1, 2, 2, 3, 3, 4, 4, 5, 6][level - 1]
+        : spells.mode == 'partial' ? [1, 1, 1, 2, 2, 3, 3, 3, 4, 4][level - 1]
+        : spells.mode == 'dual' ? [1, 1, 2, 2, 2, 3, 3, 4, 4, 5][level - 1]
+        : 0
+  spells.preparedMax:
+    type: integer
+    formula: >-
+      spells.mode == 'full' ? [3, 3, 4, 5, 6, 7, 8, 9, 10, 12][level - 1]
+        : spells.mode == 'partial' ? [2, 3, 3, 4, 5, 6, 7, 7, 8, 9][level - 1]
+        : spells.mode == 'dual' ? [3, 4, 5, 6, 8, 9, 10, 12, 13, 15][level - 1]
+        : spells.mode == 'invoker'
+          ? max(0, [2, 3, 4, 4, 5, 6, 7, 7, 8, 9][level - 1] + attributes.int.mod)
+        : spells.mode == 'partial-invoker'
+          ? max(0, [1, 3, 3, 4, 4, 5, 5, 6, 6, 7][level - 1] + attributes.int.mod)
+        : 0
+  spells.castsUsed: { type: integer, input: true, default: 0, min: 0 }
+  spells.castsLeft: { type: integer, formula: 'max(0, spells.castsPerDay - spells.castsUsed)' }
+  # An Invoker's spell points: a cast spends the spell's level.
+  spells.points:
+    type: integer
+    formula: >-
+      spells.mode == 'invoker' ? max(0, [1, 3, 4, 5, 6, 7, 8, 9, 10, 11][level - 1] + attributes.int.mod)
+        : spells.mode == 'partial-invoker'
+          ? max(0, [1, 1, 2, 2, 3, 3, 4, 4, 5, 6][level - 1] + attributes.int.mod)
+        : 0
+  spells.pointsUsed: { type: integer, input: true, default: 0, min: 0 }
+  spells.pointsLeft: { type: integer, formula: 'max(0, spells.points - spells.pointsUsed)' }
+  spells.prepared:
+    type: integer
+    formula: "countCopies(copy.type == 'spell' && copy.state.prepared)"
+  # Spells a new character knows: four for a full caster or two partial casters, two for one.
+  spells.starting:
+    type: integer
+    formula: >-
+      spells.mode == 'full' || spells.mode == 'dual' || spells.mode == 'invoker' ? 4
+        : spells.mode == 'partial' || spells.mode == 'partial-invoker' ? 2 : 0
+  # An Invoker's Traditional Education: the tradition whose spells and first-level arts they
+  # gain, or ''.
+  invoker.education: { type: string, formula: "''" }
+
+  # Effort: each tradition has its own pool. A full class's is 1 plus a skill and an attribute
+  # modifier; a partial one has 1 less; the partial-only classes give theirs whole. At least 1.
+  effort.highmage.max:
+    type: integer
+    formula: >-
+      tradition.highmage.tier == 0 ? (invoker.education == 'highmage' ? max(1, max(0, skills.magic)) : 0)
+        : max(1, 1 + max(0, skills.magic) + max(attributes.int.mod, attributes.cha.mod) - (tradition.highmage.tier == 1 ? 1 : 0))
+  effort.elementalist.max:
+    type: integer
+    formula: >-
+      tradition.elementalist.tier == 0 ? (invoker.education == 'elementalist' ? max(1, max(0, skills.magic)) : 0)
+        : max(1, 1 + max(0, skills.magic) + max(attributes.int.mod, attributes.cha.mod) - (tradition.elementalist.tier == 1 ? 1 : 0))
+  effort.necromancer.max:
+    type: integer
+    formula: >-
+      tradition.necromancer.tier == 0 ? (invoker.education == 'necromancer' ? max(1, max(0, skills.magic)) : 0)
+        : max(1, 1 + max(0, skills.magic) + max(attributes.int.mod, attributes.cha.mod) - (tradition.necromancer.tier == 1 ? 1 : 0))
+  effort.healer.max:
+    type: integer
+    formula: >-
+      tradition.healer.tier == 0 ? 0
+        : max(1, max(0, skills.heal) + max(attributes.int.mod, attributes.cha.mod))
+  effort.vowed.max:
+    type: integer
+    formula: >-
+      tradition.vowed.tier == 0 ? 0
+        : max(1, (vowed.skill == '' ? 0 : max(0, fieldOf('skills.{skill}', vowed.skill))) + attributes.bestMod)
+  effort.accursed.max:
+    type: integer
+    formula: >-
+      tradition.accursed.tier == 0 ? 0
+        : max(1, max(0, skills.magic) + max(attributes.int.mod, attributes.cha.mod))
+  effort.bard.max:
+    type: integer
+    formula: >-
+      tradition.bard.tier == 0 ? 0
+        : max(1, max(0, skills.perform) + attributes.cha.mod)
+  effort.beastmaster.max:
+    type: integer
+    formula: >-
+      tradition.beastmaster.tier == 0 ? 0
+        : max(1, max(0, skills.survive) + max(attributes.wis.mod, attributes.cha.mod))
+  effort.bloodpriest.max:
+    type: integer
+    formula: >-
+      tradition.bloodpriest.tier == 0 ? 0
+        : max(1, max(0, skills.pray) + max(attributes.wis.mod, attributes.cha.mod))
+  effort.duelist.max:
+    type: integer
+    formula: >-
+      tradition.duelist.tier == 0 ? 0
+        : max(1, max(0, skills.stab) + max(attributes.dex.mod, attributes.int.mod))
+  effort.mageslayer.max:
+    type: integer
+    formula: >-
+      tradition.mageslayer.tier == 0 ? 0
+        : max(1, max(0, skills.magic) + max(attributes.int.mod, attributes.con.mod))
+  effort.skinshifter.max:
+    type: integer
+    formula: >-
+      tradition.skinshifter.tier == 0 ? 0
+        : max(1, max(0, skills.survive) + max(attributes.con.mod, attributes.cha.mod))
+  effort.thoughtnoble.max:
+    type: integer
+    formula: >-
+      tradition.thoughtnoble.tier == 0 ? 0
+        : max(1, max(0, skills.notice) + max(attributes.int.mod, attributes.wis.mod))
+  # Effort committed for the scene, for the day, and for as long as a power lasts.
+  'effort.{effortTrad}.{effortSpan}': { type: integer, input: true, default: 0, min: 0 }
+  'effort.{effortTrad}.free':
+    type: integer
+    formula: >-
+      max(0, effort.{effortTrad}.max - effort.{effortTrad}.scene - effort.{effortTrad}.day
+        - effort.{effortTrad}.ongoing)
+
+  # The skill a Vowed's order teaches, and a Wise's, as a family key of `skill`.
+  vowed.skill: { type: string, formula: "''" }
+  wise.skill: { type: string, formula: "''" }
+  # A Wise's art progression: four arts by level 4 for a priest, witch or seer, fewer for an
+  # esoteric one.
+  wise.path: { type: enum, values: [none, priest, witch, seer, esoteric], formula: "'none'" }
+
+  # Arts picked from each tradition's list; the ones a tradition grants don't count.
+  arts.highmage.allowed:
+    type: integer
+    formula: >-
+      tradition.highmage.tier == 2 ? [2, 3, 3, 4, 4, 5, 5, 6, 6, 7][level - 1]
+        : tradition.highmage.tier == 1 ? [1, 2, 3, 3, 3, 4, 4, 4, 5, 5][level - 1]
+        : invoker.education == 'highmage' ? (tradition.invoker.tier == 2 ? 2 : 1) : 0
+  arts.elementalist.allowed:
+    type: integer
+    formula: >-
+      tradition.elementalist.tier == 2 ? [1, 2, 2, 3, 3, 4, 4, 5, 5, 6][level - 1]
+        : tradition.elementalist.tier == 1 ? [1, 1, 2, 2, 2, 3, 3, 3, 4, 4][level - 1]
+        : invoker.education == 'elementalist' ? (tradition.invoker.tier == 2 ? 1 : 1) : 0
+  arts.necromancer.allowed:
+    type: integer
+    formula: >-
+      tradition.necromancer.tier == 2 ? [2, 3, 3, 4, 4, 5, 5, 6, 6, 7][level - 1]
+        : tradition.necromancer.tier == 1 ? [1, 2, 3, 3, 3, 4, 4, 4, 5, 5][level - 1]
+        : invoker.education == 'necromancer' ? (tradition.invoker.tier == 2 ? 2 : 1) : 0
+  arts.healer.allowed:
+    type: integer
+    formula: >-
+      tradition.healer.tier > 0 ? [1, 2, 2, 3, 4, 5, 5, 6, 6, 7][level - 1] : 0
+  arts.vowed.allowed:
+    type: integer
+    formula: >-
+      tradition.vowed.tier > 0 ? [1, 2, 2, 3, 4, 5, 5, 6, 6, 7][level - 1] : 0
+  arts.accursed.allowed:
+    type: integer
+    formula: >-
+      tradition.accursed.tier > 0 ? [1, 1, 1, 1, 1, 1, 1, 1, 1, 1][level - 1] : 0
+  arts.bard.allowed:
+    type: integer
+    formula: >-
+      tradition.bard.tier > 0 ? [1, 2, 2, 3, 3, 4, 4, 5, 5, 6][level - 1] : 0
+  arts.beastmaster.allowed:
+    type: integer
+    formula: >-
+      tradition.beastmaster.tier > 0 ? [1, 2, 2, 3, 4, 5, 5, 6, 6, 7][level - 1] : 0
+  arts.bloodpriest.allowed:
+    type: integer
+    formula: >-
+      tradition.bloodpriest.tier > 0 ? [2, 3, 3, 4, 5, 6, 6, 7, 7, 8][level - 1] : 0
+  arts.duelist.allowed:
+    type: integer
+    formula: >-
+      tradition.duelist.tier > 0 ? [1, 2, 2, 3, 4, 5, 5, 6, 6, 7][level - 1] : 0
+  arts.mageslayer.allowed:
+    type: integer
+    formula: >-
+      tradition.mageslayer.tier > 0 ? [0, 0, 0, 0, 0, 0, 0, 0, 0, 0][level - 1] : 0
+  arts.skinshifter.allowed:
+    type: integer
+    formula: >-
+      tradition.skinshifter.tier > 0 ? [1, 2, 2, 3, 4, 5, 5, 6, 6, 7][level - 1] : 0
+  arts.thoughtnoble.allowed:
+    type: integer
+    formula: >-
+      tradition.thoughtnoble.tier > 0 ? [1, 2, 3, 4, 5, 6, 7, 8, 9, 10][level - 1] : 0
+  arts.wise.allowed:
+    type: integer
+    formula: >-
+      tradition.wise.tier == 0 ? 0
+        : wise.path == 'esoteric' ? [1, 1, 2, 2, 3, 3, 4, 4, 5, 5][level - 1]
+        : [1, 2, 2, 3, 4, 5, 5, 6, 6, 7][level - 1]
+  'arts.{artTrad}.taken':
+    type: integer
+    formula: "countCopies(copy.type == 'art' && copy.fields.tradition == '{artTrad}')"
+  'arts.{artTrad}.owed':
+    { type: integer, formula: 'max(0, arts.{artTrad}.allowed - arts.{artTrad}.taken)' }
+  arts.owed:
+    type: integer
+    formula: "sumList(keysOf('artTrad'), fieldOf('arts.{artTrad}.owed', x))"
+
+  # Armored Magic's level, and whether worn armor or a shield stops spells and arts.
+  magic.armoredLevel: { type: integer, formula: 0 }
+  magic.hindered:
+    type: boolean
+    formula: >-
+      (armor.wornEnc >= 0 && magic.armoredLevel < 2
+          && !(magic.armoredLevel == 1 && armor.wornEnc <= 2))
+        || (armor.shield && magic.armoredLevel < 1)
+  # Duelist arts: not in medium or heavy armor or with a large shield.
+  duelist.hindered:
+    type: boolean
+    formula: armor.wornHeavy || (armor.shield && armor.shieldAc >= 14)
+
+contentTypes:
+  # A Mage's magical tradition, picked by the Mage and the partial Mage: its `trad` key.
+  tradition:
+    grantOnly: true
+    carried: false
+    copies: { max: 0 }
+    fields:
+      key: { type: string, required: true }
+
+  spell:
+    fields:
+      level: { type: integer, required: true, min: 1, max: 5 }
+      list: { type: enum, values: [high, elementalist, necromancer], required: true, open: true }
+    state:
+      prepared: { type: boolean, default: false }
+    actions:
+      - use: cast-spell
+
+  art:
+    fields:
+      tradition:
+        type: enum
+        open: true
+        values:
+          [
+            highmage,
+            elementalist,
+            necromancer,
+            healer,
+            vowed,
+            accursed,
+            bard,
+            beastmaster,
+            bloodpriest,
+            duelist,
+            mageslayer,
+            skinshifter,
+            thoughtnoble,
+            wise,
+          ]
+        required: true
+      # How long using it commits a point of Effort, if it does.
+      effort: { type: enum, values: [none, scene, day, ongoing], default: none }
+      minLevel: { type: integer, default: 1, min: 1, max: 10 }
+      # An art that must be held first.
+      requiresArt: { type: id, of: art }
+    state:
+      # An art whose Effort stays committed while it lasts.
+      active: { type: boolean, default: false }
+    actions:
+      - use: commit-effort
+      - use: release-effort
+
+constraints:
+  - id: spells-prepared
+    check: spells.prepared <= spells.preparedMax
+    data: { limit: spells.preparedMax }
+  # A mage can learn only spells they can cast, from lists their traditions teach.
+  - id: spell-known
+    copies: { type: spell }
+    check: >-
+      item.level <= spells.maxLevel
+        && (item.list == 'high' ? spells.mode != 'none'
+          : item.list in keysOf('trad')
+            && (fieldOf('tradition.{trad}.tier', item.list) > 0 || invoker.education == item.list))
+  - id: art-tradition
+    copies: { type: art }
+    check: >-
+      fieldOf('tradition.{trad}.tier', item.tradition) > 0 || invoker.education == item.tradition
+  - id: arts-allowed
+    check: >-
+      countList(keysOf('artTrad'),
+        fieldOf('arts.{artTrad}.taken', x) > fieldOf('arts.{artTrad}.allowed', x)) == 0
+  - id: effort-committed
+    check: >-
+      countList(keysOf('effortTrad'), fieldOf('effort.{effortTrad}.scene', x)
+        + fieldOf('effort.{effortTrad}.day', x) + fieldOf('effort.{effortTrad}.ongoing', x)
+        > fieldOf('effort.{effortTrad}.max', x)) == 0
+
+actions:
+  # Casting a prepared spell spends a casting, or an Invoker's spell points.
+  - id: cast-spell
+    tags: [spell]
+    available: >-
+      self.prepared && item.level <= spells.maxLevel && !magic.hindered
+        && (spells.mode == 'invoker' || spells.mode == 'partial-invoker'
+          ? spells.pointsLeft >= item.level : spells.castsLeft > 0)
+    results: [cast]
+    steps:
+      - id: spend
+        kind: changes
+        changes:
+          - type: adjust
+            when: "spells.mode == 'invoker' || spells.mode == 'partial-invoker'"
+            field: spells.pointsUsed
+            by: item.level
+          - type: adjust
+            when: "spells.mode != 'invoker' && spells.mode != 'partial-invoker'"
+            field: spells.castsUsed
+            by: 1
+      - id: result
+        kind: outcome
+        result: "'cast'"
+        data:
+          level: item.level
+
+  - id: commit-effort
+    tags: [art]
+    available: >-
+      item.effort != 'none' && level >= item.minLevel && !(item.effort == 'ongoing' && self.active)
+        && item.tradition in keysOf('effortTrad')
+        && fieldOf('effort.{effortTrad}.free', item.tradition) > 0
+        && !(item.tradition in keysOf('armorTrad') && magic.hindered)
+        && !(item.tradition in keysOf('heavyArmorTrad') && duelist.hindered)
+    results: [committed]
+    steps:
+      - id: commit
+        kind: changes
+        changes:
+          - type: adjust
+            field:
+              {
+                formula: "fieldId('effort.{effortTrad}.{effortSpan}', item.tradition, item.effort)",
+              }
+            by: 1
+          # A copy keeps its state; an art a class grants, its grant's saved state.
+          - type: setState
+            when: "item.effort == 'ongoing' && !('granted' in item.tags)"
+            entry: self
+            key: active
+            value: true
+          - type: setState
+            when: "item.effort == 'ongoing' && 'granted' in item.tags"
+            grant: self
+            key: active
+            value: true
+      - id: result
+        kind: outcome
+        result: "'committed'"
+
+  # Reclaim the Effort an art keeps committed, ending it.
+  - id: release-effort
+    tags: [art]
+    available: "item.effort == 'ongoing' && self.active"
+    results: [released]
+    steps:
+      - id: release
+        kind: changes
+        changes:
+          - type: adjust
+            when: "fieldOf('effort.{effortTrad}.ongoing', item.tradition) > 0"
+            field: { formula: "fieldId('effort.{effortTrad}.ongoing', item.tradition)" }
+            by: -1
+          - type: setState
+            when: "!('granted' in item.tags)"
+            entry: self
+            key: active
+            value: false
+          - type: setState
+            when: "'granted' in item.tags"
+            grant: self
+            key: active
+            value: false
+      - id: result
+        kind: outcome
+        result: "'released'"

package/rules/saves.yaml

@@ -0,0 +1,62 @@
+fields:
+  # 15 at first level, one lower each level after, less the better of two attribute modifiers.
+  saves.physical:
+    type: integer
+    tags: [save, save.physical]
+    formula: 16 - level - max(attributes.str.mod, attributes.con.mod)
+  saves.evasion:
+    type: integer
+    tags: [save, save.evasion]
+    formula: 16 - level - max(attributes.dex.mod, attributes.int.mod)
+  saves.mental:
+    type: integer
+    tags: [save, save.mental]
+    formula: 16 - level - max(attributes.wis.mod, attributes.cha.mod)
+  saves.luck:
+    type: integer
+    tags: [save, save.luck]
+    formula: 16 - level
+
+situational:
+  # Nullifier: +2 on a save against magic, for the hero and allies within twenty feet.
+  - id: nullified
+    type: boolean
+    default: false
+    rolls: [save]
+    effects:
+      - target: { rolls: [save] }
+        op: add
+        value: 2
+
+resultBands:
+  save:
+    - { id: success, when: roll.total >= flags.target, success: true }
+    - { id: failure, when: true }
+
+actions:
+  # A d20 that meets or beats the save succeeds.
+  - id: saving-throw
+    tags: [save]
+    params:
+      save: { type: id, of: field, where: "'save' in item.tags" }
+      modifier: { type: integer, default: 0 }
+    results: { bands: save }
+    steps:
+      - id: setup
+        kind: branch
+        cases:
+          - when: true
+            flags: { target: params.save.value }
+      - id: save
+        kind: roll
+        tags: [{ formula: params.save.tags }]
+        bands: save
+        parts:
+          - dice: 1d20
+          - value: params.modifier
+            when: params.modifier != 0
+      - id: result
+        kind: outcome
+        result: steps.save.band
+        data:
+          total: steps.save.total

package/rules/skills.yaml

@@ -0,0 +1,93 @@
+families:
+  skill:
+    [
+      administer,
+      connect,
+      convince,
+      craft,
+      exert,
+      heal,
+      know,
+      lead,
+      magic,
+      notice,
+      perform,
+      pray,
+      punch,
+      ride,
+      sail,
+      shoot,
+      sneak,
+      stab,
+      survive,
+      trade,
+      work,
+    ]
+
+fields:
+  # -1 is no skill at all: an untrained check takes -1, which is the value itself.
+  'skills.{skill}':
+    type: integer
+    input: true
+    default: -1
+    min: -1
+    max: 4
+    tags: [skill, 'skill.{skill}']
+  # Skill points a Focus gained after first level put toward the skill that didn't buy a level.
+  'skillCredit.{skill}': { type: integer, input: true, default: 0, min: 0, max: 4 }
+
+  # Polymath: non-combat skills count as at least this level for checks.
+  skills.noncombatFloor: { type: integer, formula: -1 }
+
+  skillPoints.unspent: { type: integer, input: true, default: 0, min: 0 }
+  # The Expert's extra point each level: non-combat skills or attributes only.
+  skillPoints.expert: { type: integer, input: true, default: 0, min: 0 }
+
+constraints:
+  # No novice's skill is above level-1.
+  - id: creation-skill-cap
+    check: "!character.creating || maxFields(f.value, 'skill' in f.tags) <= 1"
+    data: { limit: 1 }
+
+resultBands:
+  check:
+    - { id: rolled, when: flags.difficulty < 0 }
+    - { id: success, when: roll.total >= flags.difficulty, success: true }
+    - { id: failure, when: true }
+
+actions:
+  # 2d6 plus the skill and an attribute modifier. The dice keep the highest two, so a Specialist's
+  # or a Gifted Chirurgeon's extra dice drop the lowest.
+  - id: skill-check
+    tags: [check]
+    params:
+      skill: { type: id, of: field, where: "'skill' in item.tags" }
+      attribute: { type: enum, values: [str, dex, con, int, wis, cha] }
+      difficulty: { type: integer, optional: true }
+      modifier: { type: integer, default: 0 }
+    results: { bands: check }
+    steps:
+      - id: setup
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              difficulty: 'has(params.difficulty) ? params.difficulty : -1'
+              level: >-
+                params.skill.id in [@skills.stab, @skills.shoot, @skills.punch]
+                  ? params.skill.value : max(params.skill.value, skills.noncombatFloor)
+      - id: check
+        kind: roll
+        tags: [check, { formula: params.skill.tags }]
+        bands: check
+        parts:
+          - dice: 2d6kh2
+          - value: flags.level
+          - field: "'attributes.' + params.attribute + '.mod'"
+          - value: params.modifier
+            when: params.modifier != 0
+      - id: result
+        kind: outcome
+        result: steps.check.band
+        data:
+          total: steps.check.total