@opencharacter/swn-revised 0.0.0-stage → 0.2.0

package/rules/checks.yaml

@@ -0,0 +1,166 @@
+fields:
+  henchmen.max: { type: integer, formula: 0 }
+  # The discipline Psychic Training's skill points go to.
+  psionics.training: { type: string, formula: "''" }
+
+situational:
+  - id: burst
+    type: boolean
+    default: false
+    rolls: [attack]
+  - id: hacking
+    type: boolean
+    default: false
+    rolls: [check.program]
+  - id: negotiation
+    type: boolean
+    default: false
+    rolls: [check]
+  - id: executionShot
+    type: boolean
+    default: false
+    rolls: [check.shoot]
+  - id: telepathy
+    type: boolean
+    default: false
+    rolls: [save.mental]
+
+resultBands:
+  check:
+    - {
+        id: success,
+        when: 'flags.difficulty >= 0 && roll.total >= flags.difficulty',
+        success: true,
+      }
+    - { id: failure, when: 'flags.difficulty >= 0' }
+    - { id: rolled, when: true }
+  # A natural 1 always fails and a natural 20 always succeeds.
+  save:
+    - {
+        id: success,
+        when: 'roll.faces[0] == 20 || (roll.faces[0] != 1 && roll.total >= flags.target)',
+        success: true,
+      }
+    - { id: failure, when: true }
+  attack:
+    - { id: hit, when: 'flags.ac >= 0 && roll.total >= flags.ac', success: true }
+    - { id: miss, when: 'flags.ac >= 0' }
+    - { id: rolled, when: true }
+
+actions:
+  # 2d6 + skill + attribute modifier; unskilled is -1. Some foci roll more dice and keep two.
+  - id: skill-check
+    tags: [check]
+    params:
+      skill:
+        type: enum
+        open: true
+        required: true
+        values:
+          &skills [
+            administer,
+            connect,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            pilot,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            biopsionics,
+            metapsionics,
+            precognition,
+            telekinesis,
+            telepathy,
+            teleportation,
+          ]
+      attribute: { type: enum, required: true, values: [str, dex, con, int, wis, cha] }
+      difficulty: { type: integer, optional: true, min: 0 }
+    results: { bands: check }
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              difficulty: 'has(params.difficulty) ? params.difficulty : -1'
+              reroll: false
+      - id: check
+        kind: roll
+        tags: &checkTags
+          - check
+          - formula: >-
+              ['check.' + params.skill]
+                + (params.skill in ['connect', 'lead', 'perform', 'talk'] ? ['check.social'] : [])
+        bands: check
+        parts: &checkParts
+          - dice: "(fieldOf('skills.{skill}.dice', params.skill))d6kh2"
+          - value: "fieldOf('skills.{skill}.level', params.skill)"
+          - value: "fieldOf('attributes.{attr}.mod', params.attribute)"
+      - id: retry
+        kind: choice
+        tags: [failed-check]
+        when: "steps.check.band == 'failure'"
+        options: [{ id: accept }]
+        recommend: "'accept'"
+      - id: reroll
+        kind: roll
+        when: flags.reroll
+        tags: *checkTags
+        bands: check
+        parts: *checkParts
+      - id: result
+        kind: outcome
+        result: >-
+          has(steps.reroll) && steps.reroll.band == 'success' ? 'success' : steps.check.band
+        data:
+          total: 'has(steps.reroll) ? max(steps.check.total, steps.reroll.total) : steps.check.total'
+
+  - id: saving-throw
+    tags: [save]
+    params:
+      save: { type: enum, required: true, values: [physical, evasion, mental] }
+      modifier: { type: integer, default: 0 }
+    results: { bands: save }
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              target: >-
+                params.save == 'physical' ? saves.physical
+                  : params.save == 'evasion' ? saves.evasion : saves.mental
+      - id: save
+        kind: roll
+        tags: [save, { formula: "'save.' + params.save" }]
+        bands: save
+        parts:
+          - dice: 1d20
+          - value: params.modifier
+      - { id: result, kind: outcome, result: steps.save.band }
+
+  - id: initiative
+    tags: [initiative]
+    results: [rolled]
+    steps:
+      - id: roll
+        kind: roll
+        tags: [initiative]
+        parts:
+          - dice: 1d8
+          - value: attributes.dex.mod
+      - id: result
+        kind: outcome
+        result: "'rolled'"
+        data: { total: steps.roll.total }

package/rules/combat.yaml

@@ -0,0 +1,321 @@
+actions:
+  # d20 + attack bonus + combat skill (unskilled -2) + the weapon's attribute modifier, against
+  # the target's AC. A miss still does the weapon's Shock if the target's AC is low enough, and a
+  # hit never does less than the Shock would.
+  - id: attack
+    tags: [attack]
+    available: >-
+      (self.equipped || 'unarmed' in item.tags) && (!has(item.magazine) || self.loaded > 0)
+    params:
+      targetAc: { type: integer, optional: true }
+      modifier: { type: integer, default: 0 }
+    participants:
+      target:
+        max: 1
+        fields:
+          ac.value: { type: integer, default: 10 }
+          ac.advanced: { type: integer }
+          psionics.cursedLuck: { type: boolean, default: false }
+    results: [hit, miss, rolled]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              skill: "fieldOf('skills.{skill}.level', item.skill)"
+              attr: >-
+                !has(item.attribute) ? 0
+                  : item.attribute == 'str-dex' ? max(attributes.str.mod, attributes.dex.mod)
+                  : fieldOf('attributes.{attr}.mod', item.attribute)
+              advanced: >-
+                item.advanced || (item.skill == 'stab' && combat.meleeAdvanced)
+                  || (item.skill == 'punch' && combat.punchAdvanced)
+              bonus: >-
+                item.skill == 'punch' ? max(0, skills.punch.level)
+                  : item.skill == 'stab' ? damage.melee : damage.ranged
+              burst: situational.burst && item.burst && self.loaded >= 3
+              hit: false
+      - id: target
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              ac: >-
+                has(item.fixedAc) ? item.fixedAc : has(params.targetAc) ? params.targetAc
+                  : size(participants.target) == 0 ? -1
+                  : flags.advanced && has(participants.target[0].ac.advanced)
+                    ? participants.target[0].ac.advanced : participants.target[0].ac.value
+      - id: roll
+        kind: roll
+        tags: [attack, { formula: "'attack.' + item.skill" }]
+        bands: attack
+        parts:
+          - dice: 1d20
+          - value: combat.attackBonus
+          - value: 'flags.skill < 0 ? -2 : flags.skill'
+          - value: flags.attr
+          - value: 'item.energy ? 1 : 0'
+          - value: 'flags.burst ? 2 : 0'
+          - value: params.modifier
+      - id: luck
+        kind: choice
+        tags: [missed-attack]
+        when: "steps.roll.band == 'miss'"
+        options: [{ id: accept }]
+        recommend: "'accept'"
+      - id: outcome
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              landed: "steps.roll.band == 'hit' || flags.hit"
+              shock: >-
+                has(item.shock) && item.shock > 0 && flags.ac >= 0
+                  && ((shock.anyAc && item.skill != 'shoot') || flags.ac <= item.shockAc)
+                  ? max(0, item.shock + flags.attr + shock.bonus
+                    + (item.skill == 'stab' ? damage.melee : 0))
+                  : 0
+      - id: damage
+        kind: roll
+        when: flags.landed
+        tags: [damage]
+        parts:
+          - dice: item.damage
+          - value: flags.attr
+          - value: flags.bonus
+          - value: 'flags.burst ? 2 : 0'
+      - id: missDamage
+        kind: roll
+        when: "!flags.landed && steps.roll.band == 'miss'"
+        tags: [damage]
+        parts:
+          - dice: "item.skill == 'punch' ? miss.punch : item.skill == 'stab' ? miss.melee : miss.ranged"
+      - id: total
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              damage: >-
+                flags.landed ? max(0, steps.damage.total, flags.shock)
+                  : has(steps.missDamage) ? flags.shock + steps.missDamage.total : 0
+      - id: deal
+        kind: changes
+        when: flags.damage > 0
+        to: target
+        changes:
+          - type: adjust
+            field: hp.current
+            by: -flags.damage
+            tags: [{ formula: "item.nonlethal ? 'damage.nonlethal' : 'damage'" }]
+      - id: spend
+        kind: changes
+        changes:
+          - type: adjustState
+            when: has(item.magazine)
+            entry: self
+            key: loaded
+            by: '-(flags.burst ? 3 : 1)'
+          - type: adjustQuantity
+            when: has(item.fixedAc)
+            entry: self
+            by: -1
+      - id: result
+        kind: outcome
+        result: "flags.landed ? 'hit' : steps.roll.band"
+        data:
+          total: steps.roll.total
+          damage: flags.damage
+
+  # Refills the magazine from a power cell or a load of ammunition carried, when there is one.
+  - id: reload
+    tags: [attack]
+    available: has(item.magazine) && self.loaded < item.magazine
+    results: [reloaded]
+    steps:
+      - id: load
+        kind: changes
+        changes:
+          - { type: setState, entry: self, key: loaded, value: item.magazine }
+          - type: adjustQuantity
+            when: has(item.ammo)
+            copies:
+              {
+                type: gear,
+                where: 'has(item.kind) && item.kind == action.item.ammo && self.quantity > 0',
+              }
+            limit: 1
+            by: -1
+      - { id: result, kind: outcome, result: "'reloaded'" }
+
+  - id: take-damage
+    tags: [health]
+    params:
+      amount: { type: integer, min: 0 }
+    results: [taken]
+    steps:
+      - id: deal
+        kind: changes
+        changes:
+          - { type: adjust, field: hp.current, by: -params.amount, tags: [damage] }
+      - { id: result, kind: outcome, result: "'taken'" }
+
+  - id: heal
+    tags: [health]
+    params:
+      amount: { type: integer, min: 0 }
+    results: [healed]
+    steps:
+      - id: restore
+        kind: changes
+        changes:
+          - { type: adjust, field: hp.current, by: params.amount, tags: [healing] }
+      - { id: result, kind: outcome, result: "'healed'" }
+
+  # A night's rest: hit points back by the character level (unless mortally wounded), one point
+  # of System Strain gone, and every Effort and once-a-scene ability back.
+  - id: rest
+    tags: [health]
+    results: [rested]
+    steps:
+      - id: rest
+        tags: [rest.night]
+        kind: changes
+        changes:
+          - { type: adjust, field: hp.current, by: level, when: hp.current > 0, tags: [healing] }
+          - { type: adjust, field: strain.current, by: -1, when: strain.current > 0 }
+          - { type: set, field: effort.day, value: 0 }
+          - { type: set, field: effort.scene, value: 0 }
+          - { type: set, field: effort.torched, value: 0 }
+          - { type: set, field: scene.expertReroll, value: false }
+          - { type: set, field: scene.warriorLuck, value: false }
+      - { id: result, kind: outcome, result: "'rested'" }
+
+  - id: end-scene
+    tags: [health]
+    results: [ended]
+    steps:
+      - id: reset
+        tags: [rest.scene]
+        kind: changes
+        changes:
+          - { type: set, field: effort.scene, value: 0 }
+          - { type: set, field: effort.torched, value: 0 }
+          - { type: set, field: scene.expertReroll, value: false }
+          - { type: set, field: scene.warriorLuck, value: false }
+      - { id: result, kind: outcome, result: "'ended'" }
+
+  # A stim or drug on yourself: it fails if its System Strain would pass Constitution.
+  - id: use-drug
+    tags: [health]
+    available: "item.category == 'pharmaceutical' && self.quantity > 0"
+    results: [applied, failed]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              fits: strain.total + item.strain <= strain.max
+      - id: heal
+        kind: roll
+        when: flags.fits && has(item.heal)
+        tags: [healing]
+        parts:
+          - dice: item.heal
+          - value: 'item.healAddsSkill ? max(0, skills.heal.level) : 0'
+      - id: apply
+        kind: changes
+        changes:
+          - { type: adjustQuantity, entry: self, by: -1 }
+          - {
+              type: adjust,
+              field: strain.current,
+              by: item.strain,
+              when: flags.fits && item.strain > 0,
+            }
+          - type: adjust
+            when: has(steps.heal)
+            field: hp.current
+            by: steps.heal.total
+            tags: [healing]
+      - { id: result, kind: outcome, result: "flags.fits ? 'applied' : 'failed'" }
+
+  - id: trigger-cyberware
+    tags: [strain]
+    available: item.activationStrain > 0
+    results: [triggered, failed]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              fits: strain.total + item.activationStrain <= strain.max
+      - id: strain
+        kind: changes
+        when: flags.fits
+        changes:
+          - { type: adjust, field: strain.current, by: item.activationStrain }
+      - { id: result, kind: outcome, result: "flags.fits ? 'triggered' : 'failed'" }
+
+  # Commit a point of Effort for the scene or for the day.
+  - id: commit-effort
+    tags: [psionics]
+    available: effort.available > 0
+    params:
+      until: { type: enum, values: [scene, day], default: scene }
+    results: [committed]
+    steps:
+      # Torched Effort lasts only for the scene, whatever it is committed for.
+      - id: source
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              day: "params.until == 'day' && effort.max - effort.scene - effort.day - effort.active > 0"
+      - id: commit
+        kind: changes
+        changes:
+          - { type: adjust, field: effort.scene, by: 1, when: '!flags.day' }
+          - { type: adjust, field: effort.day, by: 1, when: flags.day }
+      - { id: result, kind: outcome, result: "'committed'" }
+
+  # Torching: a free point of Effort for the scene, at a risk to Wisdom or Constitution.
+  - id: torch
+    tags: [psionics]
+    available: "psionics.access != 'none'"
+    results: [harmless, wisdom, constitution, chosen]
+    steps:
+      - id: roll
+        kind: roll
+        tags: [torch]
+        parts: [{ dice: 1d6 }]
+      - id: attribute
+        kind: choice
+        when: steps.roll.total == 5
+        options: { values: { formula: "keysOf('attr')" } }
+        recommend: >-
+          ['str', 'dex', 'con', 'int', 'wis', 'cha'][indexOf([attributes.str.score,
+            attributes.dex.score, attributes.con.score, attributes.int.score,
+            attributes.wis.score, attributes.cha.score], maxList([attributes.str.score,
+            attributes.dex.score, attributes.con.score, attributes.int.score,
+            attributes.wis.score, attributes.cha.score], x))]
+      - id: apply
+        kind: changes
+        changes:
+          - { type: adjust, field: effort.torched, by: 1 }
+          - { type: adjust, field: attributes.wis.score, by: -1, when: steps.roll.total <= 2 }
+          - type: adjust
+            when: steps.roll.total == 3 || steps.roll.total == 4
+            field: attributes.con.score
+            by: -1
+          - type: adjust
+            when: has(steps.attribute)
+            field: { formula: "'attributes.' + steps.attribute.picked + '.score'" }
+            by: -1
+      - id: result
+        kind: outcome
+        result: >-
+          steps.roll.total <= 2 ? 'wisdom' : steps.roll.total <= 4 ? 'constitution'
+            : steps.roll.total == 5 ? 'chosen' : 'harmless'

package/rules/core.yaml

@@ -0,0 +1,111 @@
+settings:
+  rounding: floor
+  rollModifiers:
+    advantage: cancel
+
+families:
+  attr: [str, dex, con, int, wis, cha]
+  # Every skill, for fieldOf; the fields are declared by the three families below.
+  skill:
+    [
+      administer,
+      connect,
+      exert,
+      fix,
+      heal,
+      know,
+      lead,
+      notice,
+      perform,
+      pilot,
+      program,
+      punch,
+      shoot,
+      sneak,
+      stab,
+      survive,
+      talk,
+      trade,
+      work,
+      biopsionics,
+      metapsionics,
+      precognition,
+      telekinesis,
+      telepathy,
+      teleportation,
+    ]
+  general:
+    [
+      administer,
+      connect,
+      exert,
+      fix,
+      heal,
+      know,
+      lead,
+      notice,
+      perform,
+      pilot,
+      program,
+      sneak,
+      survive,
+      talk,
+      trade,
+      work,
+    ]
+  combat: [punch, shoot, stab]
+  psychic: [biopsionics, metapsionics, precognition, telekinesis, telepathy, teleportation]
+
+fields:
+  'attributes.{attr}.score':
+    { type: integer, input: true, default: 10, min: 0, max: 18, tags: [attribute] }
+  'attributes.{attr}.mod':
+    type: integer
+    tags: [attr-mod]
+    formula: >-
+      attributes.{attr}.score <= 3 ? -2 : attributes.{attr}.score <= 7 ? -1
+        : attributes.{attr}.score <= 13 ? 0 : attributes.{attr}.score <= 17 ? 1 : 2
+
+  level: { type: integer, input: true, default: 1, min: 1, max: 20 }
+  xp.current: { type: integer, input: true, default: 0, min: 0 }
+  # The total the next level needs: the table to 10th level, then 24 more for each level.
+  xp.next:
+    type: integer
+    formula: 'level >= 10 ? 93 + 24 * (level - 9) : [0, 3, 6, 12, 18, 27, 39, 54, 72, 93][level]'
+
+  # Unskilled is -1: a skill check adds it as the penalty, an attack swaps it for -2.
+  'skills.{general}.level':
+    { type: integer, input: true, default: -1, min: -1, max: 4, tags: [skill, skill.general] }
+  'skills.{combat}.level':
+    { type: integer, input: true, default: -1, min: -1, max: 4, tags: [skill, skill.combat] }
+  'skills.{psychic}.level':
+    { type: integer, input: true, default: -1, min: -1, max: 4, tags: [skill, skill.psychic] }
+  # How many d6 a check in the skill rolls, keeping the best two.
+  'skills.{general}.dice': { type: integer, formula: 2, min: 2 }
+  'skills.{combat}.dice': { type: integer, formula: 2, min: 2 }
+  'skills.{psychic}.dice': { type: integer, formula: 2, min: 2 }
+
+  saves.physical:
+    type: integer
+    tags: [save]
+    formula: 16 - level - max(attributes.str.mod, attributes.con.mod)
+  saves.evasion:
+    type: integer
+    tags: [save]
+    formula: 16 - level - max(attributes.dex.mod, attributes.int.mod)
+  saves.mental:
+    type: integer
+    tags: [save]
+    formula: 16 - level - max(attributes.wis.mod, attributes.cha.mod)
+
+  # The rolled part of maximum hit points, Constitution included; the per-level bonuses
+  # (Warrior, Partial Warrior, Die Hard) are added on top, so a bonus taken later counts for
+  # every level.
+  hp.rolled: { type: integer, input: true, default: 1, min: 1 }
+  hp.perLevel: { type: integer, formula: 0 }
+  hp.max: { type: integer, formula: hp.rolled + hp.perLevel * level, min: 1 }
+  hp.current: { type: integer, input: true, default: 1, min: 0, max: hp.max }
+
+  combat.attackBonus: { type: integer, formula: floor(level / 2) }
+
+  credits.current: { type: integer, input: true, default: 0, min: 0 }