@opencharacter/cwn-srd 0.0.0-stage → 0.1.0

package/rules/layout.yaml

@@ -0,0 +1,417 @@
+display:
+  groups:
+    - id: summary
+      priority: 0
+      visibility: primary
+    - id: attributes
+      priority: 0
+      members: { type: field, where: "'attribute' in item.tags" }
+    - id: skills
+      priority: 0
+      members: { type: field, where: "'skill' in item.tags" }
+    - id: saves
+      priority: 1
+      members: { type: field, where: "'save' in item.tags" }
+    - id: combat
+      priority: 1
+    - id: strain
+      priority: 1
+    - id: hacking
+      priority: 2
+      showWhen: skills.program.base >= 0 || hacking.memory.max > 0 || hacking.cpu > 0
+    - id: magic
+      priority: 2
+      showWhen: magic.mage || magic.summoner || magic.graced
+    - id: alienation
+      priority: 2
+      showWhen: campaign.alienation
+    - id: possessions
+      priority: 2
+    - id: advancement
+      priority: 3
+    - id: training
+      priority: 3
+      visibility: background
+    - id: campaign
+      priority: 4
+      visibility: background
+
+    - id: checks
+      kind: actions
+      priority: 0
+      members: { type: action, where: "'check' in item.tags || 'save' in item.tags" }
+    - id: attacks
+      kind: actions
+      priority: 0
+      members: { type: action, where: "'attack' in item.tags || 'reload' in item.tags" }
+    - id: combat-actions
+      kind: actions
+      priority: 1
+      members:
+        type: action
+        where: >-
+          'initiative' in item.tags || 'healing' in item.tags || 'injury' in item.tags
+            || 'drug' in item.tags || 'cyber' in item.tags
+    - id: hacking-actions
+      kind: actions
+      priority: 1
+      members: { type: action, where: "'hacking' in item.tags" }
+    - id: magic-actions
+      kind: actions
+      priority: 1
+      members: { type: action, where: "'magic' in item.tags" }
+    - id: rests
+      kind: actions
+      priority: 2
+      members: { type: action, where: "'rest' in item.tags" }
+    - id: advancement-actions
+      kind: actions
+      priority: 3
+      visibility: background
+      members: { type: action, where: "'advancement' in item.tags" }
+    - id: creation
+      kind: actions
+      priority: 3
+      visibility: background
+      members: { type: action, where: "'creation' in item.tags || 'building' in item.tags" }
+
+    - id: background
+      kind: content
+      priority: 0
+      showWhen: hasChoice('background')
+      members: { type: background }
+    - id: edges
+      kind: content
+      priority: 0
+      showWhen: hasChoice('edge')
+      members: { type: edge }
+    - id: foci
+      kind: content
+      priority: 0
+      members: { type: focus }
+    - id: contacts
+      kind: content
+      priority: 1
+      members: { type: contact }
+      sortBy: "self.bond == 'friend' ? 0 : 1"
+    - id: weapons
+      kind: content
+      priority: 1
+      members: { type: weapon }
+    - id: armor
+      kind: content
+      priority: 1
+      members: { type: armor }
+    - id: cyberware
+      kind: content
+      priority: 1
+      members: { type: cyberware }
+      sectionBy: item.category
+    - id: skillplugs
+      kind: content
+      priority: 2
+      members: { type: skillplug }
+    - id: gear
+      kind: content
+      priority: 2
+      members: { type: gear }
+    - id: drugs
+      kind: content
+      priority: 2
+      members: { type: drug }
+    - id: cyberdecks
+      kind: content
+      priority: 2
+      members: { type: cyberdeck }
+    - id: programs
+      kind: content
+      priority: 2
+      members: { type: program }
+      sectionBy: item.kind
+    - id: drones
+      kind: content
+      priority: 2
+      members: { type: drone }
+    - id: vehicles
+      kind: content
+      priority: 2
+      members: { type: vehicle }
+    - id: spells
+      kind: content
+      priority: 2
+      showWhen: magic.mage
+      members: { type: spell }
+      sortBy: 'self.prepared ? 0 : 1'
+    - id: arts
+      kind: content
+      priority: 2
+      showWhen: magic.graced
+      members: { type: art }
+    - id: spirits
+      kind: content
+      priority: 2
+      showWhen: magic.summoner
+      members: { type: spirit }
+    - id: syndromes
+      kind: content
+      priority: 2
+      showWhen: campaign.alienation
+      members: { type: syndrome }
+
+  fields:
+    # Summary
+    level: { groups: [summary, advancement], priority: 0 }
+    hp.current:
+      groups: [summary]
+      priority: 1
+      input: { widget: number }
+      with: [{ field: hp.max, as: max }]
+    strain.total: { groups: [summary, strain], priority: 2, with: [{ field: strain.max, as: max }] }
+    ac.ranged: { groups: [summary, combat], priority: 3 }
+    ac.melee: { groups: [summary, combat], priority: 4 }
+    combat.attackBonus: { groups: [summary, combat], priority: 5, format: signed }
+    trauma.target: { groups: [summary, combat], priority: 6 }
+    soak.current:
+      groups: [summary, combat]
+      priority: 7
+      showWhen: soak.max > 0
+      with: [{ field: soak.max, as: max }]
+
+    # Attributes: the score with its modifier.
+    'attributes.{attribute}.score':
+      priority: 0
+      with: [{ field: 'attributes.{attribute}.mod', as: modifier }]
+    'attributes.{attribute}.mod': { format: signed, visibility: background }
+    'attributes.{attribute}.base': { groups: [training], priority: 0 }
+    'attributes.{attribute}.scoreMod': { hidden: true }
+    'attributes.{attribute}.modBonus': { hidden: true }
+    'attributes.{attribute}.modCap': { hidden: true }
+    attributes.modTotal: { groups: [training], priority: 1, format: signed }
+
+    # Skills: the level checks use; the trained level and banked points are kept out of play.
+    'skills.{skill}.level':
+      format: { bands: skill-level }
+      rolls: [{ action: skill-check, params: { skill: 'skills.{skill}.level' } }]
+      showWhen: "!('{skill}' in ['cast', 'summon']) || campaign.magic || skills.{skill}.base >= 0"
+    'skills.{skill}.base':
+      groups: [training]
+      priority: 2
+      format: { bands: skill-level }
+      showWhen: "!('{skill}' in ['cast', 'summon']) || campaign.magic || skills.{skill}.base >= 0"
+    'skills.{skill}.credit':
+      { groups: [training], priority: 3, showWhen: 'skills.{skill}.credit > 0' }
+    skills.work.profession: { groups: [skills], priority: 99 }
+
+    # Saves
+    'saves.{save}':
+      rolls: [{ action: saving-throw, params: { save: '{save}' } }]
+
+    # Combat
+    combat.initiative:
+      { groups: [combat], priority: 7, format: signed, rolls: [{ action: initiative }] }
+    combat.damageBonus:
+      { groups: [combat], priority: 8, format: signed, showWhen: combat.damageBonus != 0 }
+    combat.traumaBonus:
+      { groups: [combat], priority: 9, format: signed, showWhen: combat.traumaBonus != 0 }
+    combat.move: { groups: [combat], priority: 10, unit: m }
+    ac.ranged.base: { groups: [combat], priority: 11, visibility: background }
+    ac.melee.base: { groups: [combat], priority: 12, visibility: background }
+    soak.max: { groups: [combat], priority: 13, visibility: background }
+    armor.heavy: { groups: [combat], priority: 14, showWhen: armor.heavy > 0 }
+    hp.max: { groups: [combat], priority: 15, visibility: background }
+    hp.rolled: { groups: [combat], priority: 16, visibility: background }
+    hp.frail: { groups: [combat], priority: 17 }
+    hp.dieBonus: { groups: [training], priority: 4, showWhen: hp.dieBonus != 0 }
+    combat.shockAc: { hidden: true }
+    combat.shockBonus: { hidden: true }
+    combat.meleeSkillDamage: { hidden: true }
+    combat.rangedSkillDamage: { hidden: true }
+    combat.meleeHitBonus: { hidden: true }
+    drones.attackBonus:
+      groups: [combat]
+      priority: 18
+      format: signed
+      showWhen: "countCopies(copy.type == 'drone') > 0"
+    drones.commandable:
+      groups: [combat]
+      priority: 19
+      showWhen: "countCopies(copy.type == 'drone') > 0"
+
+    # System Strain
+    strain.temporary: { groups: [strain], priority: 3 }
+    strain.permanent: { groups: [strain], priority: 4 }
+    strain.max: { groups: [strain], priority: 5, visibility: background }
+    strain.cyber: { groups: [strain], priority: 6, visibility: background }
+    strain.cyberIgnored: { groups: [strain], priority: 7, showWhen: strain.cyberIgnored > 0 }
+    strain.maintenanceRelief: { groups: [strain], priority: 8, visibility: background }
+    strain.otherPermanent: { groups: [strain], priority: 9, visibility: background }
+    strain.constitution: { hidden: true }
+    lifestyle.strain: { hidden: true }
+    cyber.eyes: { hidden: true }
+    cyber.ears: { hidden: true }
+    cyber.plugJack: { hidden: true }
+    cyber.plugWiring: { hidden: true }
+    cyber.wiredBudget: { groups: [training], priority: 10, showWhen: cyber.wiredBudget > 0 }
+    cyber.wiredUsed: { groups: [training], priority: 11, showWhen: cyber.wiredBudget > 0 }
+
+    # Alienation
+    alienation.total:
+      { groups: [alienation], priority: 0, with: [{ field: alienation.max, as: max }] }
+    alienation.current: { groups: [alienation], priority: 1 }
+    alienation.permanent: { groups: [alienation], priority: 2 }
+    alienation.max: { groups: [alienation], priority: 3, visibility: background }
+
+    # Hacking
+    hacking.access.current:
+      groups: [hacking]
+      priority: 0
+      with: [{ field: hacking.access.max, as: max }]
+    hacking.access.spent: { groups: [hacking], priority: 1, visibility: background }
+    hacking.cpu: { groups: [hacking], priority: 2 }
+    hacking.memory.used:
+      { groups: [hacking], priority: 3, with: [{ field: hacking.memory.max, as: max }] }
+    hacking.shielding.current:
+      groups: [hacking]
+      priority: 4
+      with: [{ field: hacking.shielding.max, as: max }]
+    hacking.datafiles: { groups: [hacking], priority: 5 }
+    hacking.programming.used:
+      groups: [hacking]
+      priority: 6
+      showWhen: hacking.programming.max > 0
+      with: [{ field: hacking.programming.max, as: max }]
+    hacking.deck.bonusAccess: { groups: [hacking], priority: 7, visibility: background }
+    hacking.memory.perElement: { hidden: true }
+
+    # Magic
+    effort.mage.current:
+      groups: [magic]
+      priority: 0
+      showWhen: magic.mage
+      with: [{ field: effort.mage.max, as: max }]
+    effort.mage.scene: { groups: [magic], priority: 1, showWhen: magic.mage }
+    effort.mage.day: { groups: [magic], priority: 2, showWhen: magic.mage }
+    spells.prepared:
+      groups: [magic]
+      priority: 3
+      showWhen: magic.mage
+      with: [{ field: spells.preparedMax, as: max }]
+    effort.summoner.current:
+      groups: [magic]
+      priority: 4
+      showWhen: magic.summoner
+      with: [{ field: effort.summoner.max, as: max }]
+    effort.summoner.scene: { groups: [magic], priority: 5, showWhen: magic.summoner }
+    effort.summoner.day: { groups: [magic], priority: 6, showWhen: magic.summoner }
+    arts.spent:
+      groups: [magic]
+      priority: 7
+      showWhen: magic.graced
+      with: [{ field: arts.points, as: max }]
+    magic.cyberPenalty: { groups: [magic], priority: 8, showWhen: magic.cyberPenalty > 0 }
+    magic.mage: { hidden: true }
+    magic.summoner: { hidden: true }
+    magic.graced: { hidden: true }
+
+    # Possessions
+    money: { groups: [summary, possessions], priority: 8 }
+    lifestyle: { groups: [possessions], priority: 1 }
+    enc.readied:
+      groups: [possessions]
+      priority: 2
+      with: [{ field: enc.readiedMax, as: max }]
+    enc.stowed:
+      groups: [possessions]
+      priority: 3
+      with: [{ field: enc.stowedMax, as: max }]
+    enc.overload: { groups: [possessions], priority: 4, showWhen: enc.overload > 0 }
+    budget.vehicle:
+      groups: [possessions]
+      priority: 5
+      showWhen: budget.vehicle > 0
+      with: [{ field: budget.vehicleUsed, as: detail }]
+    budget.drone:
+      groups: [possessions]
+      priority: 6
+      showWhen: budget.drone > 0
+      with: [{ field: budget.droneUsed, as: detail }]
+    maintenance.used:
+      groups: [possessions]
+      priority: 7
+      showWhen: maintenance.max > 0 || maintenance.used > 0
+      with: [{ field: maintenance.max, as: max }]
+    maintenance.multiplier: { hidden: true }
+    maintenance.fixBonus: { hidden: true }
+    languages.extra: { groups: [possessions], priority: 8 }
+    languages.known: { groups: [possessions], priority: 9 }
+    goal: { groups: [possessions], priority: 10 }
+
+    # Advancement
+    xp.current: { groups: [advancement], priority: 1, with: [{ field: xp.next, as: max }] }
+    xp.track: { groups: [advancement], priority: 2, visibility: background }
+    skillPoints.unspent: { groups: [advancement], priority: 3 }
+    foci.taken: { groups: [advancement], priority: 4, with: [{ field: foci.allowed, as: max }] }
+    advancement.attributeBoosts: { groups: [advancement], priority: 5, visibility: background }
+    underdog: { groups: [advancement], priority: 6, visibility: background }
+    skillPoints.perLevel: { groups: [training], priority: 5 }
+    edges.taken: { hidden: true }
+
+    # Campaign options
+    campaign.magic: { groups: [campaign], priority: 0 }
+    campaign.alienation: { groups: [campaign], priority: 1 }
+
+  types:
+    background: { quantity: { hidden: true } }
+    focus:
+      quantity: { hidden: true }
+      state:
+        level: { priority: 0, input: { widget: dots } }
+    contact:
+      quantity: { hidden: true }
+      state:
+        bond: { priority: 0 }
+        about: { priority: 1 }
+    weapon:
+      state:
+        loaded: { priority: 0, showWhen: has(item.magazine) }
+      fields:
+        damage: { format: dice }
+        traumaDie: { format: dice }
+        rangeNormal: { unit: m }
+        rangeLong: { unit: m }
+    armor:
+      state:
+        soakUsed: { priority: 0, showWhen: self.soakUsed > 0 }
+    cyberware:
+      quantity: { hidden: true }
+      state:
+        damaged: { priority: 0 }
+        wired: { priority: 1, visibility: background }
+    cyberdeck:
+      state:
+        shieldingUsed: { priority: 0, showWhen: self.shieldingUsed > 0 }
+    program:
+      quantity: { hidden: true }
+      state:
+        source: { priority: 0, visibility: background }
+    drone:
+      state:
+        hp: { priority: 0 }
+        focusGear: { priority: 1, visibility: background }
+      fields:
+        move: { unit: m }
+    vehicle:
+      state:
+        hp: { priority: 0 }
+        focusGear: { priority: 1, visibility: background }
+    spell:
+      quantity: { hidden: true }
+      state:
+        prepared: { priority: 0 }
+    art: { quantity: { hidden: true } }
+    spirit:
+      quantity: { hidden: true }
+      state:
+        form: { priority: 0 }
+        ritual: { priority: 1 }
+    syndrome: { quantity: { hidden: true } }

package/rules/magic.yaml

@@ -0,0 +1,199 @@
+# 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
+        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
+    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, size(picksOf('powers')) - (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:
+    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 }
+    steps:
+      - id: commit
+        kind: changes
+        changes:
+          - type: adjust
+            field: effort.summoner.day
+            by: 'self.cost + (self.ritual ? 0 : params.earlier)'

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