@opencharacter/cwn-srd 0.0.0-stage → 0.2.0

package/rules/building.yaml

@@ -0,0 +1,467 @@
+# The building blocks creation and advancement share: gaining a skill, an attribute bonus, an
+# Edge and a Focus. Each takes `random`, which draws its picks instead of recommending them.
+actions:
+  # A skill pick. During creation the skill goes up one level: the first time to level-0, the
+  # second to level-1, and a third time the player picks any other skill not already level-1.
+  # During advancement (a Focus's or Edge's bonus skill) it is three skill points toward the
+  # skill, which may raise it past the level the character could normally buy; what doesn't buy a
+  # level stays as credit toward it. On a skill already at level-4 the points go to the pool.
+  - id: gain-skill
+    listed: false
+    tags: [building]
+    params:
+      code:
+        type: enum
+        open: true
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            cast,
+            summon,
+            combat,
+            any,
+            punch-stab,
+            noncombat,
+          ]
+      random: { type: boolean, default: false }
+    results: [raised, points]
+    steps:
+      - id: start
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              points: '!character.creating'
+              candidates: >-
+                filterList(keysOf('skill'),
+                  (params.code == x
+                    || (params.code == 'combat' && x in ['punch', 'shoot', 'stab'])
+                    || (params.code == 'punch-stab' && x in ['punch', 'stab'])
+                    || (params.code == 'noncombat'
+                      && !(x in ['punch', 'shoot', 'stab', 'cast', 'summon']))
+                    || (params.code == 'any' && !(x in ['cast', 'summon'])))
+                  && (!character.creating || fieldOf('skills.{skill}.base', x) < 1))
+      # Every skill the pick could name is level-1 already: any other non-magical skill.
+      - id: fallback
+        kind: branch
+        sheet: proposed
+        when: size(flags.candidates) == 0
+        cases:
+          - when: true
+            flags:
+              candidates: >-
+                filterList(keysOf('skill'),
+                  !(x in ['cast', 'summon']) && fieldOf('skills.{skill}.base', x) < 1)
+      - id: skill
+        kind: choice
+        tags: [skill-pick]
+        options: { values: { formula: flags.candidates } }
+        when: size(flags.candidates) > 1
+        random: params.random
+        recommend: flags.candidates[0]
+      # A single candidate needs no question.
+      - id: picked
+        kind: branch
+        cases:
+          - when: true
+            flags: { skill: 'has(steps.skill) ? steps.skill.picked : flags.candidates[0]' }
+      - id: raise
+        kind: changes
+        when: '!flags.points'
+        changes:
+          - type: adjust
+            field: { formula: "fieldId('skills.{skill}.base', flags.skill)" }
+            by: 1
+      # Three points (and any credit) buy levels in order: level-0 costs 1, level-1 2, and so on.
+      - id: pool
+        kind: branch
+        sheet: proposed
+        when: flags.points
+        cases:
+          - when: true
+            flags:
+              level: fieldOf('skills.{skill}.base', flags.skill)
+              pool: 3 + fieldOf('skills.{skill}.credit', flags.skill)
+      - id: buy1
+        kind: branch
+        when: flags.points && flags.level < 4 && flags.pool >= flags.level + 2
+        cases:
+          - when: true
+            flags: { pool: flags.pool - flags.level - 2, level: flags.level + 1 }
+      - id: buy2
+        kind: branch
+        when: flags.points && flags.level < 4 && flags.pool >= flags.level + 2
+        cases:
+          - when: true
+            flags: { pool: flags.pool - flags.level - 2, level: flags.level + 1 }
+      - id: buy3
+        kind: branch
+        when: flags.points && flags.level < 4 && flags.pool >= flags.level + 2
+        cases:
+          - when: true
+            flags: { pool: flags.pool - flags.level - 2, level: flags.level + 1 }
+      - id: spend
+        kind: changes
+        when: flags.points
+        changes:
+          - type: set
+            field: { formula: "fieldId('skills.{skill}.base', flags.skill)" }
+            value: flags.level
+          - type: set
+            field: { formula: "fieldId('skills.{skill}.credit', flags.skill)" }
+            value: 'flags.level >= 4 ? 0 : flags.pool'
+          - type: adjust
+            when: flags.level >= 4 && flags.pool > 0
+            field: skillPoints.unspent
+            by: flags.pool
+      - id: done
+        kind: outcome
+        result: "flags.points ? 'points' : 'raised'"
+        data: { skill: flags.skill }
+
+  # An attribute bonus from a background's Growth table: +1 to any attribute, or +2 to physical
+  # or mental attributes, split between two of them as the player likes. No score passes 18.
+  - id: gain-attribute
+    listed: false
+    tags: [building]
+    params:
+      code: { type: enum, values: [any-stat-1, physical-2, mental-2] }
+      random: { type: boolean, default: false }
+    results: [raised]
+    steps:
+      - id: start
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              amount: "params.code == 'any-stat-1' ? 1 : 2"
+              group: >-
+                params.code == 'physical-2' ? ['str', 'dex', 'con']
+                  : params.code == 'mental-2' ? ['int', 'wis', 'cha']
+                  : ['str', 'dex', 'con', 'int', 'wis', 'cha']
+      # The recommendation: all of it to the highest score it fits under 18.
+      - id: best
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              best: >-
+                sortList(filterList(flags.group,
+                  fieldOf('attributes.{attribute}.base', x) <= 18 - flags.amount),
+                  -fieldOf('attributes.{attribute}.base', x))
+      - id: boost
+        kind: allocate
+        sheet: proposed
+        fields:
+          type: field
+          where: >-
+            'attribute-base' in item.tags
+              && countList(flags.group, ('attr.' + x) in item.tags) > 0
+        budget: flags.amount
+        spend: upTo
+        limit: 18 - field.value
+        random: params.random
+        recommend:
+          'attributes.{attribute}.base': >-
+            size(flags.best) > 0 && flags.best[0] == '{attribute}' ? flags.amount : 0
+      - { id: result, kind: outcome, result: "'raised'" }
+
+  # A new Focus at level 1, or a Focus the character has raised to level 2, with its bonus skill
+  # and the gear it brings.
+  - id: gain-focus
+    available: foci.taken < foci.allowed
+    tags: [building, advancement]
+    params:
+      random: { type: boolean, default: false }
+    results: [gained]
+    steps:
+      # A new Focus, or the second level of one the character has: asked only when there is one
+      # to raise.
+      - id: mode
+        kind: choice
+        sheet: proposed
+        when: "countCopies(copy.type == 'focus' && copy.state.level < copy.fields.maxLevel) > 0"
+        options: [{ id: new }, { id: raise }]
+        recommend: "'new'"
+        random: params.random
+      - id: picked
+        kind: branch
+        cases:
+          - when: true
+            flags: { mode: "has(steps.mode) ? steps.mode.picked : 'new'" }
+      - id: focus
+        kind: choice
+        when: flags.mode == 'new'
+        tags: [focus-pick]
+        sheet: proposed
+        options:
+          content:
+            type: focus
+            where: >-
+              ('repeatable' in item.tags || countCopies(copy.item == item.id) == 0)
+                && !('brings-cyber' in item.tags
+                  && (magic.graced || countCopies('bars-cyber' in copy.tags) > 0))
+                && !('bars-cyber' in item.tags && (underdog || magic.mage || magic.summoner
+                  || magic.graced || countCopies(copy.type == 'cyberware' && copy.fields.strain > 0) > 0))
+        recommend: options[0]
+        random: params.random
+      - id: raised
+        kind: choice
+        when: flags.mode == 'raise'
+        sheet: proposed
+        options:
+          copies: { type: focus, where: self.level < item.maxLevel }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - { type: setState, entry: picked, key: level, value: 2 }
+      # The Specialist's skill, which is its bonus skill too.
+      - id: specialty
+        kind: choice
+        when: has(steps.focus) && has(steps.focus.item.bonusSkill) && steps.focus.item.bonusSkill == 'noncombat'
+        options:
+          values:
+            [
+              administer,
+              connect,
+              drive,
+              exert,
+              fix,
+              heal,
+              know,
+              lead,
+              notice,
+              perform,
+              program,
+              sneak,
+              survive,
+              talk,
+              trade,
+              work,
+            ]
+        recommend: options[0]
+        random: params.random
+      # All Natural's first attribute pick.
+      - id: attribute
+        kind: choice
+        when: has(steps.focus) && 'asks-attribute' in steps.focus.item.tags
+        options: { values: [str, dex, con, int, wis, cha] }
+        recommend: options[0]
+        random: params.random
+      - id: add
+        kind: changes
+        when: has(steps.focus)
+        changes:
+          - type: addItem
+            when: '!has(steps.specialty) && !has(steps.attribute)'
+            entry: { item: steps.focus.picked }
+          - type: addItem
+            when: has(steps.specialty)
+            entry:
+              item: steps.focus.picked
+              choices: { skill: [{ option: { formula: steps.specialty.picked } }] }
+          - type: addItem
+            when: has(steps.attribute)
+            entry:
+              item: steps.focus.picked
+              choices: { attribute-1: [{ option: { formula: steps.attribute.picked } }] }
+          - type: addItem
+            forEach: steps.focus.item.startingItems
+            entry: { item: x }
+      # The new Focus's other choices (All Natural's later attribute picks).
+      - id: picks
+        kind: choice
+        when: has(steps.focus)
+        options: { pending: { entry: 'steps.add.added[0]' } }
+        random: params.random
+      - id: cyber
+        kind: changes
+        sheet: proposed
+        when: >-
+          has(steps.focus) && size(steps.focus.item.startingCyber) > 0
+            && strain.total + steps.focus.item.startingCyberStrain <= strain.max && !magic.graced
+        changes:
+          - type: addItem
+            forEach: steps.focus.item.startingCyber
+            entry: { item: x }
+      - id: bonus
+        kind: action
+        when: has(steps.focus) && has(steps.focus.item.bonusSkill)
+        use: gain-skill
+        params:
+          code: "steps.focus.item.bonusSkill == 'noncombat' ? steps.specialty.picked : steps.focus.item.bonusSkill"
+          random: params.random
+      - id: bonus2
+        kind: action
+        when: has(steps.focus) && has(steps.focus.item.bonusSkill2)
+        use: gain-skill
+        params: { code: steps.focus.item.bonusSkill2, random: params.random }
+      - id: levelTwo
+        kind: action
+        when: has(steps.raised) && has(steps.raised.item.levelTwoSkill)
+        use: gain-skill
+        params: { code: steps.raised.item.levelTwoSkill, random: params.random }
+      - id: gear
+        kind: action
+        when: has(steps.focus) && has(steps.focus.item.gearBudget)
+        use: acquire-focus-gear
+        params: { kind: steps.focus.item.gearBudget, random: params.random }
+      - { id: done, kind: outcome, result: "'gained'" }
+
+  # An Edge in one of the rules' Edge choices, with its bonus skill and what it brings.
+  - id: gain-edge
+    tags: [building]
+    available: >-
+      size(picksOf('edge-1')) == 0 || size(picksOf('edge-2')) == 0
+        || (level >= 5 && size(picksOf('edge-5')) == 0)
+        || (underdog && size(picksOf('underdog-edge')) == 0)
+    params:
+      choice: { type: enum, values: [edge-1, edge-2, edge-5, underdog-edge] }
+      random: { type: boolean, default: false }
+    results: [gained, closed]
+    steps:
+      # The 5th-level Edge waits for 5th level, the Underdog Rule's for the rule; a taken one is
+      # taken.
+      - id: closed
+        kind: outcome
+        sheet: proposed
+        when: >-
+          (params.choice == 'edge-5' && level < 5) || (params.choice == 'underdog-edge' && !underdog)
+            || (params.choice == 'edge-1' && size(picksOf('edge-1')) > 0)
+            || (params.choice == 'edge-2' && size(picksOf('edge-2')) > 0)
+            || (params.choice == 'edge-5' && size(picksOf('edge-5')) > 0)
+            || (params.choice == 'underdog-edge' && size(picksOf('underdog-edge')) > 0)
+        result: "'closed'"
+      - id: edge
+        kind: choice
+        tags: [edge-pick]
+        sheet: proposed
+        options:
+          content:
+            type: edge
+            where: >-
+              ('repeatable' in item.tags || !(item.id in edges.taken))
+                && (!item.magic || (campaign.magic && params.choice != 'underdog-edge'
+                  && params.choice != 'edge-5'))
+                && !('not-underdog' in item.tags && (underdog || params.choice == 'underdog-edge'))
+                && !('brings-cyber' in item.tags
+                  && (magic.graced || countCopies('bars-cyber' in copy.tags) > 0))
+        recommend: options[0]
+        random: params.random
+        changes:
+          - { type: choose, path: { choice: '[params.choice]' }, option: picked.id }
+      - id: attribute
+        kind: choice
+        when: steps.edge.item.asksAttribute
+        options: { values: [str, dex, int, wis, cha] }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - type: choose
+            path: { choice: "[params.choice, steps.edge.picked, 'attribute']" }
+            option: picked.id
+      - id: bonus
+        kind: action
+        when: has(steps.edge.item.bonusSkill)
+        use: gain-skill
+        params: { code: steps.edge.item.bonusSkill, random: params.random }
+      # Educated's bonus skill point per level counts from 1st level when it is taken later.
+      - id: retro
+        kind: changes
+        sheet: proposed
+        when: "!character.creating && 'retroactive-points' in steps.edge.item.tags"
+        changes:
+          - { type: adjust, field: skillPoints.unspent, by: level - 1 }
+      - id: items
+        kind: changes
+        when: size(steps.edge.item.startingItems) > 0 || steps.edge.item.friendContacts > 0
+        changes:
+          - type: addItem
+            forEach: steps.edge.item.startingItems
+            entry: { item: x }
+          - type: addItem
+            when: steps.edge.item.friendContacts > 0
+            entry: { item: "'contacts.contact'", state: { bond: "'friend'" } }
+      - id: cyber
+        kind: changes
+        sheet: proposed
+        when: >-
+          size(steps.edge.item.startingCyber) > 0
+            && strain.total + steps.edge.item.startingCyberStrain <= strain.max && !magic.graced
+        changes:
+          - type: addItem
+            forEach: steps.edge.item.startingCyber
+            entry: { item: x }
+      - id: programs
+        kind: choice
+        when: steps.edge.item.programElements > 0
+        sheet: proposed
+        options:
+          content: { type: program, where: picks == 0 }
+        repeat: { max: steps.edge.item.programElements, min: steps.edge.item.programElements }
+        random: params.random
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { item: picked.id, state: { source: "'edge'" } }
+      - id: wired
+        kind: action
+        when: steps.edge.item.cyberBudget > 0
+        use: acquire-wired-cyber
+        params: { random: params.random }
+      - id: spells
+        kind: choice
+        when: steps.edge.item.spells > 0
+        sheet: proposed
+        options:
+          content: { type: spell, where: picks == 0 }
+        repeat: { max: steps.edge.item.spells, min: steps.edge.item.spells }
+        random: params.random
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      # Graced: the first level's art points.
+      - id: arts
+        kind: choice
+        when: steps.edge.item.buysArts
+        sheet: proposed
+        options:
+          content:
+            type: art
+            where: >-
+              item.cost <= arts.points - arts.spent && countCopies(copy.item == item.id) == 0
+                && !('alacrity' in item.tags && countCopies('alacrity' in copy.tags) > 0)
+        repeat: { max: 4 }
+        random: params.random
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      - id: focus
+        kind: action
+        when: steps.edge.item.extraFocus
+        use: gain-focus
+        params: { random: params.random }
+      - { id: done, kind: outcome, result: "'gained'" }

package/rules/character.yaml

@@ -0,0 +1,100 @@
+families:
+  save: [physical, evasion, mental, luck]
+
+fields:
+  # Optional rules the campaign uses. Magic opens the magical Edges and skills; alienation tracks
+  # the psychological cost of cyber.
+  campaign.magic: { type: boolean, input: true, default: false }
+  campaign.alienation: { type: boolean, input: true, default: false }
+
+  # Experience levels run from 1 to 10. The table is the fast or the slow one.
+  level: { type: integer, input: true, default: 1, min: 1, max: 10 }
+  xp.current: { type: integer, input: true, default: 0, min: 0 }
+  xp.track: { type: enum, values: [fast, slow], input: true, default: fast }
+  # The experience total the next level needs (0 at 10th level).
+  xp.next:
+    type: integer
+    formula: >-
+      level >= 10 ? 0
+        : (xp.track == 'fast' ? [0, 3, 6, 12, 18, 27, 39, 54, 72, 93]
+          : [0, 6, 15, 24, 36, 51, 69, 87, 105, 139])[level]
+
+  # Hit points: the rolled maximum is saved; the maximum is what effects make of it.
+  hp.rolled: { type: integer, input: true, default: 1, min: 1 }
+  hp.max: { type: integer, formula: hp.rolled, min: 1 }
+  hp.current: { type: integer, input: true, default: 0, min: 0, max: hp.max }
+  # Frail: stabilized from mortal injury. Another drop to zero kills; no natural healing.
+  hp.frail: { type: boolean, input: true, default: false }
+
+  # Saving throws: roll 1d20 equal or over the target. 16 minus level and the better modifier.
+  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 }
+
+  # Combat basics.
+  combat.attackBonus: { type: integer, formula: floor(level / 2) }
+  # Added to every hit point damage roll and to Shock (Killing Blow).
+  combat.damageBonus: { type: integer, formula: '0' }
+  # Added to every Trauma Die the character rolls.
+  combat.traumaBonus: { type: integer, formula: '0' }
+  combat.initiative: { type: integer, formula: attributes.dex.mod }
+  combat.move: { type: integer, formula: '10' }
+  trauma.target: { type: integer, formula: '6' }
+  # Armor Class before Dexterity: 10 unarmored, or what armor or dermal plating sets.
+  ac.ranged.base: { type: integer, formula: '10' }
+  ac.melee.base: { type: integer, formula: '10' }
+  ac.ranged: { type: integer, formula: ac.ranged.base + attributes.dex.mod }
+  ac.melee: { type: integer, formula: ac.melee.base + attributes.dex.mod }
+
+  # Money and lifestyle. Lifestyle moves the System Strain maximum.
+  money: { type: integer, input: true, default: 0, min: 0 }
+  lifestyle:
+    type: enum
+    values: [squatter, slum, middle, fine, luxury]
+    input: true
+    default: middle
+  lifestyle.strain:
+    type: integer
+    formula: "[-2, -1, 0, 1, 2][indexOf(['squatter', 'slum', 'middle', 'fine', 'luxury'], lifestyle)]"
+
+  # Starting languages beyond the city's lingua franca and a native tongue: one for Know or
+  # Connect at level-0, two at level-1 or better, each.
+  languages.extra:
+    type: integer
+    formula: >-
+      (skills.know.level >= 1 ? 2 : skills.know.level >= 0 ? 1 : 0)
+        + (skills.connect.level >= 1 ? 2 : skills.connect.level >= 0 ? 1 : 0)
+  languages.known: { type: string, input: true, default: '' }
+
+  # Character advancement.
+  skillPoints.unspent: { type: integer, input: true, default: 0, min: 0 }
+  # Skill points spent on attribute boosts: at most five, ever.
+  advancement.attributeBoosts: { type: integer, input: true, default: 0, min: 0, max: 5 }
+  # The Underdog Rule: a bonus Edge for a modifier total of -1 or less. It forbids buying
+  # attribute boosts later.
+  underdog: { type: boolean, input: true, default: false }
+
+  # Notes the player writes: a name is the app's; the goal is part of the sheet.
+  goal: { type: string, input: true, default: '' }
+
+constraints:
+  # The Underdog Rule's modifier total holds at the end of creation; later gains don't matter.
+  - id: underdog-modifiers
+    check: '!character.creating || !underdog || attributes.modTotal <= -1'
+  - id: underdog-boosts
+    check: '!underdog || advancement.attributeBoosts == 0'
+
+followUps:
+  - id: level-up
+    while: '!character.creating && level < 10 && xp.current >= xp.next'
+    action: level-up