@opencharacter/cwn-srd 0.0.0-stage → 0.2.0

package/rules/checks.yaml

@@ -0,0 +1,187 @@
+settings:
+  # Rerolled or extra-die skill checks (Specialist, Healer, Sniper's Eye) don't stack: the best
+  # applies.
+  stacking:
+    keys: { skill-dice: highestOnly }
+
+resultBands:
+  check:
+    - { id: success, when: roll.total >= flags.dc, success: true }
+    - { id: failure, when: true }
+  # A natural 1 always fails a save and a natural 20 always succeeds.
+  save:
+    - { id: failure, when: 'roll.kept[0] == 1' }
+    - { id: success, when: 'roll.kept[0] == 20 || roll.total >= flags.target', success: true }
+    - { id: failure, when: true }
+  major-injury:
+    - { id: death, when: roll.total <= 1 }
+    - { id: internal, when: roll.total == 2 }
+    - { id: brain, when: roll.total == 3 }
+    - { id: eye, when: roll.total == 4 }
+    - { id: gut, when: roll.total == 5 }
+    - { id: right-leg, when: roll.total == 6 }
+    - { id: left-leg, when: roll.total == 7 }
+    - { id: right-arm, when: roll.total == 8 }
+    - { id: left-arm, when: roll.total == 9 }
+    - { id: system, when: roll.total == 10 }
+    - { id: flesh-wound, when: true }
+
+actions:
+  # A skill check: 2d6 plus the skill level (-1 untrained) and an attribute modifier, against a
+  # difficulty from 6 (simple) to 14+ (near impossible).
+  - 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, optional: true }
+    results: [success, failure, rolled]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags: { dc: 'has(params.difficulty) ? params.difficulty : -1' }
+      - id: check
+        kind: roll
+        tags:
+          - skill-check
+          - { formula: params.skill.tags }
+          - { formula: "'attr.' + params.attribute" }
+        bands: check
+        parts:
+          - { dice: 2d6kh2, tags: [skill-dice] }
+          - field: params.skill.id
+          - field: "'attributes.' + params.attribute + '.mod'"
+          - { value: params.modifier, when: has(params.modifier) }
+      - id: result
+        kind: outcome
+        result: "flags.dc < 0 ? 'rolled' : steps.check.band"
+        data: { total: steps.check.total }
+
+  # A saving throw: 1d20 equal or over the save's target.
+  - id: saving-throw
+    tags: [save]
+    params:
+      save: { type: enum, values: [physical, evasion, mental, luck] }
+      modifier: { type: integer, optional: true }
+    results: [success, failure]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags: { target: "fieldOf('saves.{save}', params.save)" }
+      - id: save
+        kind: roll
+        tags: [save, { formula: "'save.' + params.save" }]
+        bands: save
+        parts:
+          - dice: 1d20
+          - { value: params.modifier, when: has(params.modifier) }
+      - id: result
+        kind: outcome
+        result: steps.save.band
+        data: { total: steps.save.total, target: flags.target }
+
+  # Initiative: 1d8 plus the Dexterity modifier (the side rolls with its best).
+  - id: initiative
+    tags: [initiative]
+    results: [rolled]
+    steps:
+      - id: roll
+        kind: roll
+        tags: [initiative]
+        parts:
+          - dice: 1d8
+          - field: "'combat.initiative'"
+      - { id: result, kind: outcome, result: "'rolled'", data: { total: steps.roll.total } }
+
+  # The end of a fight or scene: Damage Soak and deck Shielding refresh, scene Effort returns.
+  - id: end-scene
+    tags: [rest]
+    results: [ended]
+    steps:
+      - id: refresh
+        tags: [rest.scene]
+        kind: changes
+        changes:
+          - type: setState
+            copies: { type: armor, where: self.soakUsed > 0 }
+            key: soakUsed
+            value: 0
+          - type: setState
+            copies: { type: cyberdeck, where: self.shieldingUsed > 0 }
+            key: shieldingUsed
+            value: 0
+          - { type: set, field: effort.mage.scene, value: 0 }
+          - { type: set, field: effort.summoner.scene, value: 0 }
+      - { id: result, kind: outcome, result: "'ended'" }
+
+  # A night's rest, warm and fed: hit points equal to the level (none while Frail), one point of
+  # System Strain, all Effort Committed for the day, the day's Access and Martial Instinct's rolls.
+  - id: rest
+    tags: [rest]
+    results: [rested]
+    steps:
+      - id: recover
+        tags: [rest.night]
+        kind: changes
+        changes:
+          - { type: adjust, when: '!hp.frail', field: hp.current, by: level }
+          - { type: adjust, when: strain.temporary > 0, field: strain.temporary, by: -1 }
+          - { type: set, field: effort.mage.day, value: 0 }
+          - { type: set, field: effort.mage.scene, value: 0 }
+          - { type: set, field: effort.summoner.day, value: 0 }
+          - { type: set, field: effort.summoner.scene, value: 0 }
+          - { type: set, field: hacking.access.spent, value: 0 }
+          - { type: set, field: arts.bonusRolls.used, value: 0 }
+      - { id: result, kind: outcome, result: "'rested'" }
+
+  # First aid from a medic: 1d6 plus their Heal skill (1d6-1 without one), and one System
+  # Strain. It can't be applied past the System Strain maximum.
+  - id: first-aid
+    tags: [healing]
+    available: strain.total + 1 <= strain.max
+    params:
+      healerSkill: { type: integer, min: -1, max: 4 }
+    results: [healed]
+    steps:
+      - id: heal
+        kind: roll
+        tags: [healing, first-aid]
+        parts:
+          - dice: 1d6
+          - value: params.healerSkill
+      - id: apply
+        kind: changes
+        changes:
+          - { type: adjust, field: hp.current, by: 'max(0, steps.heal.total)' }
+          - { type: adjust, field: strain.temporary, by: 1 }
+      - {
+          id: result,
+          kind: outcome,
+          result: "'healed'",
+          data: { healed: 'max(0, steps.heal.total)' },
+        }
+
+  # A Major Injury: after a failed Physical save at zero hit points in a scene with a Traumatic
+  # Hit, roll 1d12 on the table.
+  - id: major-injury
+    tags: [injury]
+    results: [rolled]
+    params:
+      modifier: { type: integer, optional: true }
+    steps:
+      - id: roll
+        kind: roll
+        tags: [major-injury]
+        bands: major-injury
+        parts:
+          - dice: 1d12
+          - { value: params.modifier, when: has(params.modifier) }
+      - id: result
+        kind: outcome
+        result: "'rolled'"
+        data: { injury: steps.roll.band }

package/rules/contacts.yaml

@@ -0,0 +1,10 @@
+contentTypes:
+  # A Contact: an NPC the character knows, named by the player. Acquaintances deal honestly and do
+  # safe favors; Friends take real risks for the character.
+  contact:
+    nameFrom: label
+    state:
+      label: { type: string, default: '' }
+      bond: { type: enum, values: [acquaintance, friend], default: acquaintance }
+      # Their profession and how the character knows them.
+      about: { type: string, default: '' }

package/rules/creation.yaml

@@ -0,0 +1,398 @@
+creation:
+  - { id: guided, action: create-character }
+  - { id: random, action: create-character, params: { random: true }, random: true }
+
+actions:
+  # Character creation in the book's order: attributes, background and its skills, two Edges,
+  # a Focus, the Underdog Rule, hit points, the free skill, Contacts and starting gear. The
+  # random start rolls the attributes in order and the background's skills, as the book does, and
+  # draws every pick the book leaves to the player.
+  - id: create-character
+    tags: [creation]
+    available: character.creating
+    params:
+      random: { type: boolean, default: false }
+    results: [created]
+    steps:
+      # Attributes: 3d6 in order, one of them may become 14; or the array 14, 12, 11, 10, 9, 7.
+      - id: method
+        kind: choice
+        options: [{ id: roll }, { id: array }]
+        recommend: "'roll'"
+      - id: str
+        kind: roll
+        tags: [creation]
+        when: steps.method.picked == 'roll'
+        parts: [{ dice: 3d6 }]
+      - id: dex
+        kind: roll
+        tags: [creation]
+        when: steps.method.picked == 'roll'
+        parts: [{ dice: 3d6 }]
+      - id: con
+        kind: roll
+        tags: [creation]
+        when: steps.method.picked == 'roll'
+        parts: [{ dice: 3d6 }]
+      - id: int
+        kind: roll
+        tags: [creation]
+        when: steps.method.picked == 'roll'
+        parts: [{ dice: 3d6 }]
+      - id: wis
+        kind: roll
+        tags: [creation]
+        when: steps.method.picked == 'roll'
+        parts: [{ dice: 3d6 }]
+      - id: cha
+        kind: roll
+        tags: [creation]
+        when: steps.method.picked == 'roll'
+        parts: [{ dice: 3d6 }]
+      - id: rolled
+        kind: branch
+        when: steps.method.picked == 'roll'
+        cases:
+          - when: true
+            flags:
+              totals: >-
+                [steps.str.total, steps.dex.total, steps.con.total, steps.int.total,
+                  steps.wis.total, steps.cha.total]
+      # The recommendation: the lowest score, if it is under 14.
+      - id: substitute
+        kind: choice
+        when: steps.method.picked == 'roll'
+        options:
+          - { id: none }
+          - { id: str, when: steps.str.total < 14 }
+          - { id: dex, when: steps.dex.total < 14 }
+          - { id: con, when: steps.con.total < 14 }
+          - { id: int, when: steps.int.total < 14 }
+          - { id: wis, when: steps.wis.total < 14 }
+          - { id: cha, when: steps.cha.total < 14 }
+        recommend: >-
+          minList(flags.totals, x) >= 14 ? 'none'
+            : ['str', 'dex', 'con', 'int', 'wis', 'cha'][
+              indexOf(flags.totals, minList(flags.totals, x))]
+      - id: scores
+        kind: changes
+        when: steps.method.picked == 'roll'
+        changes:
+          - type: set
+            field: attributes.str.base
+            value: "steps.substitute.picked == 'str' ? 14 : steps.str.total"
+          - type: set
+            field: attributes.dex.base
+            value: "steps.substitute.picked == 'dex' ? 14 : steps.dex.total"
+          - type: set
+            field: attributes.con.base
+            value: "steps.substitute.picked == 'con' ? 14 : steps.con.total"
+          - type: set
+            field: attributes.int.base
+            value: "steps.substitute.picked == 'int' ? 14 : steps.int.total"
+          - type: set
+            field: attributes.wis.base
+            value: "steps.substitute.picked == 'wis' ? 14 : steps.wis.total"
+          - type: set
+            field: attributes.cha.base
+            value: "steps.substitute.picked == 'cha' ? 14 : steps.cha.total"
+      - id: array
+        kind: allocate
+        when: steps.method.picked == 'array'
+        fields: { type: field, where: "'attribute-base' in item.tags" }
+        values: [14, 12, 11, 10, 9, 7]
+        random: params.random
+        recommend:
+          attributes.str.base: 10
+          attributes.dex.base: 14
+          attributes.con.base: 12
+          attributes.int.base: 11
+          attributes.wis.base: 9
+          attributes.cha.base: 7
+
+      # Background: its free skill, then three rolls on its tables or two picks from Learning.
+      - id: background
+        kind: choice
+        options: { content: { type: background } }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - { type: choose, path: { choice: [background] }, option: picked.id }
+      - id: freeSkill
+        kind: action
+        use: gain-skill
+        params: { code: steps.background.item.freeSkill, random: params.random }
+      - id: tables
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              growth: >-
+                [steps.background.item.growth1, steps.background.item.growth2,
+                  steps.background.item.growth3, steps.background.item.growth4,
+                  steps.background.item.growth5, steps.background.item.growth6]
+              learning: >-
+                [steps.background.item.learning1, steps.background.item.learning2,
+                  steps.background.item.learning3, steps.background.item.learning4,
+                  steps.background.item.learning5, steps.background.item.learning6,
+                  steps.background.item.learning7, steps.background.item.learning8]
+      - id: skillMethod
+        kind: choice
+        options: [{ id: roll }, { id: pick }]
+        recommend: "params.random ? 'roll' : 'pick'"
+      - id: table1
+        kind: choice
+        when: steps.skillMethod.picked == 'roll'
+        options: [{ id: growth }, { id: learning }]
+        recommend: "'learning'"
+        random: params.random
+      - id: roll1
+        kind: roll
+        tags: [creation]
+        when: steps.skillMethod.picked == 'roll'
+        parts: [{ dice: "steps.table1.picked == 'growth' ? 1d6 : 1d8" }]
+      - id: entry1
+        kind: branch
+        when: steps.skillMethod.picked == 'roll'
+        cases:
+          - when: true
+            flags:
+              entry: >-
+                steps.table1.picked == 'growth' ? flags.growth[steps.roll1.total - 1]
+                  : flags.learning[steps.roll1.total - 1]
+      - id: skill1
+        kind: action
+        when: "steps.skillMethod.picked == 'roll' && !(flags.entry in ['any-stat-1', 'physical-2', 'mental-2'])"
+        use: gain-skill
+        params: { code: flags.entry, random: params.random }
+      - id: stat1
+        kind: action
+        when: "steps.skillMethod.picked == 'roll' && flags.entry in ['any-stat-1', 'physical-2', 'mental-2']"
+        use: gain-attribute
+        params: { code: flags.entry, random: params.random }
+      - id: table2
+        kind: choice
+        when: steps.skillMethod.picked == 'roll'
+        options: [{ id: growth }, { id: learning }]
+        recommend: "'learning'"
+        random: params.random
+      - id: roll2
+        kind: roll
+        tags: [creation]
+        when: steps.skillMethod.picked == 'roll'
+        parts: [{ dice: "steps.table2.picked == 'growth' ? 1d6 : 1d8" }]
+      - id: entry2
+        kind: branch
+        when: steps.skillMethod.picked == 'roll'
+        cases:
+          - when: true
+            flags:
+              entry: >-
+                steps.table2.picked == 'growth' ? flags.growth[steps.roll2.total - 1]
+                  : flags.learning[steps.roll2.total - 1]
+      - id: skill2
+        kind: action
+        when: "steps.skillMethod.picked == 'roll' && !(flags.entry in ['any-stat-1', 'physical-2', 'mental-2'])"
+        use: gain-skill
+        params: { code: flags.entry, random: params.random }
+      - id: stat2
+        kind: action
+        when: "steps.skillMethod.picked == 'roll' && flags.entry in ['any-stat-1', 'physical-2', 'mental-2']"
+        use: gain-attribute
+        params: { code: flags.entry, random: params.random }
+      - id: table3
+        kind: choice
+        when: steps.skillMethod.picked == 'roll'
+        options: [{ id: growth }, { id: learning }]
+        recommend: "'learning'"
+        random: params.random
+      - id: roll3
+        kind: roll
+        tags: [creation]
+        when: steps.skillMethod.picked == 'roll'
+        parts: [{ dice: "steps.table3.picked == 'growth' ? 1d6 : 1d8" }]
+      - id: entry3
+        kind: branch
+        when: steps.skillMethod.picked == 'roll'
+        cases:
+          - when: true
+            flags:
+              entry: >-
+                steps.table3.picked == 'growth' ? flags.growth[steps.roll3.total - 1]
+                  : flags.learning[steps.roll3.total - 1]
+      - id: skill3
+        kind: action
+        when: "steps.skillMethod.picked == 'roll' && !(flags.entry in ['any-stat-1', 'physical-2', 'mental-2'])"
+        use: gain-skill
+        params: { code: flags.entry, random: params.random }
+      - id: stat3
+        kind: action
+        when: "steps.skillMethod.picked == 'roll' && flags.entry in ['any-stat-1', 'physical-2', 'mental-2']"
+        use: gain-attribute
+        params: { code: flags.entry, random: params.random }
+      - id: pick1
+        kind: choice
+        when: steps.skillMethod.picked == 'pick'
+        options: { values: { formula: "filterList(flags.learning, x != 'any')" } }
+        recommend: filterList(flags.learning, x != 'any')[0]
+        random: params.random
+      - id: learned1
+        kind: action
+        when: steps.skillMethod.picked == 'pick'
+        use: gain-skill
+        params: { code: steps.pick1.picked, random: params.random }
+      - id: pick2
+        kind: choice
+        when: steps.skillMethod.picked == 'pick'
+        options: { values: { formula: "filterList(flags.learning, x != 'any')" } }
+        recommend: filterList(flags.learning, x != 'any')[1]
+        random: params.random
+      - id: learned2
+        kind: action
+        when: steps.skillMethod.picked == 'pick'
+        use: gain-skill
+        params: { code: steps.pick2.picked, random: params.random }
+
+      # Two Edges and a Focus (more with Focused).
+      - id: edge1
+        kind: action
+        use: gain-edge
+        params: { choice: "'edge-1'", random: params.random }
+      - id: edge2
+        kind: action
+        use: gain-edge
+        params: { choice: "'edge-2'", random: params.random }
+      - id: focus
+        kind: action
+        use: gain-focus
+        params: { random: params.random }
+
+      # The Underdog Rule: a modifier total of -1 or less earns a bonus, non-magical Edge.
+      - id: modifiers
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags: { underdog: 'attributes.modTotal <= -1 && !(@edges.prodigy in edges.taken)' }
+      - id: underdog
+        kind: choice
+        when: flags.underdog
+        options: [{ id: take }, { id: decline }]
+        recommend: "'take'"
+        changes:
+          - { type: set, when: "picked.id == 'take'", field: underdog, value: true }
+      - id: underdogEdge
+        kind: action
+        when: has(steps.underdog) && steps.underdog.picked == 'take'
+        use: gain-edge
+        params: { choice: "'underdog-edge'", random: params.random }
+
+      # Hit points: 1d6 plus the Constitution modifier (and Hard to Kill's +2), at least 1.
+      - id: hp
+        kind: roll
+        tags: [creation, hit-points]
+        sheet: proposed
+        parts:
+          - dice: 1d6
+          - field: "'attributes.con.mod'"
+          - field: "'hp.dieBonus'"
+      - id: hpMax
+        kind: changes
+        changes:
+          - { type: set, field: hp.rolled, value: 'max(1, steps.hp.total)' }
+
+      # The free skill: any skill but a magical one.
+      - id: freePick
+        kind: action
+        use: gain-skill
+        params: { code: "'any'", random: params.random }
+
+      # Contacts: two Acquaintances or one Friend.
+      - id: contacts
+        kind: choice
+        options: [{ id: acquaintances }, { id: friend }]
+        recommend: "'acquaintances'"
+        random: params.random
+        changes:
+          - type: addItem
+            when: "picked.id == 'acquaintances'"
+            entry: { item: "'contacts.contact'", state: { bond: "'acquaintance'" } }
+          - type: addItem
+            when: "picked.id == 'acquaintances'"
+            entry: { item: "'contacts.contact'", state: { bond: "'acquaintance'" } }
+          - type: addItem
+            when: "picked.id == 'friend'"
+            entry: { item: "'contacts.contact'", state: { bond: "'friend'" } }
+
+      # Gear: $500 to spend, one item of up to $1,000 and a month of middle-class life.
+      - id: freeItemKind
+        tags: [creation.item]
+        kind: choice
+        options: [{ id: weapon }, { id: armor }, { id: gear }, { id: cyberdeck }, { id: drone }]
+        recommend: "'weapon'"
+        random: params.random
+      - id: freeWeapon
+        kind: choice
+        when: steps.freeItemKind.picked == 'weapon'
+        options:
+          content: { type: weapon, where: "item.cost <= 1000 && !('restricted' in item.tags)" }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      - id: freeArmor
+        kind: choice
+        when: steps.freeItemKind.picked == 'armor'
+        options:
+          content: { type: armor, where: "item.cost <= 1000 && !('restricted' in item.tags)" }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      - id: freeGear
+        kind: choice
+        when: steps.freeItemKind.picked == 'gear'
+        options:
+          content: { type: gear, where: "item.cost <= 1000 && !('restricted' in item.tags)" }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      - id: freeCyberdeck
+        kind: choice
+        when: steps.freeItemKind.picked == 'cyberdeck'
+        options:
+          content: { type: cyberdeck, where: "item.cost <= 1000 && !('restricted' in item.tags)" }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      - id: freeDrone
+        kind: choice
+        when: steps.freeItemKind.picked == 'drone'
+        options:
+          content: { type: drone, where: "item.cost <= 1000 && !('restricted' in item.tags)" }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      - id: gear
+        tags: [creation.gear]
+        kind: changes
+        changes:
+          - { type: set, field: money, value: 500 }
+          - { type: set, field: lifestyle, value: "'middle'" }
+
+      - id: finish
+        tags: [creation.finish]
+        kind: changes
+        sheet: proposed
+        changes:
+          - { type: set, field: hp.current, value: hp.max }
+          - { type: finishCreation }
+      - { id: done, kind: outcome, result: "'created'" }