@opencharacter/swn-revised 0.0.0-stage → 0.2.0

package/rules/layout.yaml

@@ -0,0 +1,197 @@
+display:
+  groups:
+    - id: attributes
+      priority: 0
+      members: { type: field, where: "'attribute' in item.tags" }
+    - id: saves
+      priority: 0
+      members: { type: field, where: "'save' in item.tags" }
+    - id: skills
+      priority: 0
+      members: { type: field, where: "'skill.general' in item.tags || 'skill.combat' in item.tags" }
+    - id: psychic-skills
+      priority: 1
+      showWhen: "psionics.access != 'none'"
+      members: { type: field, where: "'skill.psychic' in item.tags" }
+    - id: condition
+      priority: 0
+    - id: combat
+      priority: 0
+    - id: psionics
+      priority: 1
+      showWhen: "psionics.access != 'none' || effort.max > 0"
+    - id: advancement
+      priority: 2
+    - id: carrying
+      priority: 2
+    - id: attacks
+      kind: actions
+      priority: 0
+      members: { type: action, where: "'attack' in item.tags || 'combat' in item.tags" }
+    - id: checks
+      kind: actions
+      priority: 0
+      members:
+        type: action
+        where: "'check' in item.tags || 'save' in item.tags || 'initiative' in item.tags"
+    - id: health-actions
+      kind: actions
+      priority: 1
+      members: { type: action, where: "'health' in item.tags || 'strain' in item.tags" }
+    - id: psionic-actions
+      kind: actions
+      priority: 1
+      members: { type: action, where: "'psionics' in item.tags" }
+    - id: advancement-actions
+      kind: actions
+      priority: 2
+      visibility: background
+      members: { type: action, where: "'level-up' in item.tags || 'creation' in item.tags" }
+    - id: class
+      kind: content
+      priority: 0
+      members: { type: class }
+    - id: background
+      kind: content
+      priority: 0
+      members: { type: background }
+    - id: foci
+      kind: content
+      priority: 0
+      members: { type: focus }
+    - id: techniques
+      kind: content
+      priority: 1
+      showWhen: "hasChoice('technique') || psionics.access != 'none' || effort.max > 0"
+      members: { type: technique }
+      sectionBy: item.level
+    - id: weapons
+      kind: content
+      priority: 1
+      members: { type: weapon }
+    - id: armor
+      kind: content
+      priority: 1
+      members: { type: armor }
+    - id: gear
+      kind: content
+      priority: 2
+      members: { type: gear }
+      sectionBy: item.category
+    - id: cyberware
+      kind: content
+      priority: 2
+      members: { type: cyberware }
+  types:
+    class: { quantity: { hidden: true } }
+    background: { quantity: { hidden: true } }
+    focus:
+      quantity: { hidden: true }
+      state:
+        level: { priority: 0 }
+    technique:
+      quantity: { hidden: true }
+      state:
+        committed: { priority: 0, showWhen: self.committed > 0 }
+        torched: { hidden: true }
+    cyberware: { quantity: { hidden: true } }
+    weapon:
+      state:
+        loaded: { priority: 0, input: { widget: track }, showWhen: has(item.magazine) }
+      fields:
+        damage: { format: dice }
+  fields:
+    level: { groups: [advancement], priority: 0, visibility: primary }
+    xp.current: { groups: [advancement], priority: 0, with: [{ field: xp.next, as: max }] }
+    xp.next: { groups: [advancement], priority: 1 }
+    skillPoints.general: { groups: [advancement], priority: 1 }
+    skillPoints.expert: { groups: [advancement], priority: 1, showWhen: class.expertPoints > 0 }
+    skillPoints.psychic:
+      { groups: [advancement], priority: 1, showWhen: "psionics.access != 'none'" }
+    skillPoints.training: { groups: [advancement], priority: 1, showWhen: skillPoints.training > 0 }
+    attributes.boosts: { groups: [advancement], priority: 2 }
+    'skills.{skill}.credit':
+      { groups: [advancement], priority: 3, showWhen: 'skills.{skill}.credit > 0' }
+    hp.current:
+      groups: [condition]
+      priority: 0
+      visibility: primary
+      with: [{ field: hp.max, as: max }]
+      rolls: [{ action: take-damage }, { action: heal }]
+    hp.max: { groups: [condition], priority: 1 }
+    hp.rolled: { groups: [condition], priority: 2, visibility: background }
+    hp.perLevel: { hidden: true }
+    strain.current:
+      groups: [condition]
+      priority: 0
+      with: [{ field: strain.max, as: max }, { field: strain.permanent, as: detail }]
+    strain.total: { groups: [condition], priority: 1 }
+    strain.permanent: { groups: [condition], priority: 1 }
+    strain.max: { groups: [condition], priority: 1 }
+    scene.expertReroll:
+      groups: [condition]
+      priority: 1
+      showWhen: 'countCopies(copy.item == @classes.expert) > 0'
+      input: { widget: checkbox }
+    scene.warriorLuck:
+      groups: [condition]
+      priority: 1
+      showWhen: 'countCopies(copy.item == @classes.warrior) > 0'
+      input: { widget: checkbox }
+    ac.value: { groups: [combat], priority: 0, visibility: primary }
+    ac.advanced: { groups: [combat], priority: 1 }
+    combat.attackBonus: { groups: [combat], priority: 0, visibility: primary }
+    credits.current: { groups: [carrying], priority: 0 }
+    encumbrance.readied:
+      { groups: [carrying], priority: 0, with: [{ field: encumbrance.readiedLimit, as: max }] }
+    encumbrance.stowed:
+      { groups: [carrying], priority: 0, with: [{ field: encumbrance.stowedLimit, as: max }] }
+    encumbrance.level: { groups: [carrying], priority: 1 }
+    movement: { groups: [carrying], priority: 1 }
+    henchmen.max: { groups: [carrying], priority: 2, showWhen: henchmen.max > 0 }
+    effort.available:
+      groups: [psionics]
+      priority: 0
+      with: [{ field: effort.max, as: max }]
+      rolls: [{ action: commit-effort }]
+    effort.max: { groups: [psionics], priority: 1 }
+    effort.scene: { groups: [psionics], priority: 1 }
+    effort.day: { groups: [psionics], priority: 1 }
+    effort.active: { groups: [psionics], priority: 1, showWhen: effort.active > 0 }
+    effort.torched: { groups: [psionics], priority: 2 }
+    psionics.access: { groups: [psionics], priority: 1 }
+    psionics.discipline:
+      { groups: [psionics], priority: 1, showWhen: "psionics.discipline != 'none'" }
+    psionics.training: { hidden: true }
+    effort.bonus: { hidden: true }
+    effort.wild: { hidden: true }
+    class.focus.combat: { hidden: true }
+    class.focus.noncombat: { hidden: true }
+    class.expertPoints: { hidden: true }
+    ac.armor: { hidden: true }
+    ac.innate: { hidden: true }
+    ac.shield: { hidden: true }
+    damage.melee: { hidden: true }
+    damage.ranged: { hidden: true }
+    shock.bonus: { hidden: true }
+    shock.anyAc: { hidden: true }
+    miss.melee: { hidden: true }
+    miss.ranged: { hidden: true }
+    miss.punch: { hidden: true }
+    combat.meleeAdvanced: { hidden: true }
+    combat.punchAdvanced: { hidden: true }
+    encumbrance.strength: { hidden: true }
+    'attributes.{attr}.score':
+      with: [{ field: 'attributes.{attr}.mod', as: detail }]
+    'skills.{general}.level':
+      rolls: [{ action: skill-check, params: { skill: '{general}' } }]
+    'skills.{combat}.level':
+      rolls: [{ action: skill-check, params: { skill: '{combat}' } }]
+    'skills.{psychic}.level':
+      rolls: [{ action: skill-check, params: { skill: '{psychic}' } }]
+    'skills.{general}.dice': { hidden: true }
+    'skills.{combat}.dice': { hidden: true }
+    'skills.{psychic}.dice': { hidden: true }
+    saves.physical: { rolls: [{ action: saving-throw, params: { save: physical } }] }
+    saves.evasion: { rolls: [{ action: saving-throw, params: { save: evasion } }] }
+    saves.mental: { rolls: [{ action: saving-throw, params: { save: mental } }] }

package/rules/psionics.yaml

@@ -0,0 +1,165 @@
+fields:
+  # Cursed Luck is on the character: attacks against them and damage they take roll twice and
+  # keep the better.
+  psionics.cursedLuck: { type: boolean, formula: false }
+  effort.bonus: { type: integer, formula: 0 }
+  # A wild talent's Effort, for a character who isn't a psychic.
+  effort.wild: { type: integer, formula: 0 }
+  effort.max:
+    type: integer
+    formula: >-
+      psionics.access == 'none' ? effort.wild
+        : max(1, 1 + maxFields(f.value, 'skill.psychic' in f.tags)
+          + max(attributes.wis.mod, attributes.con.mod)) + effort.bonus
+  # Effort Committed until the end of the scene, and until the next night's rest.
+  effort.scene: { type: integer, input: true, default: 0, min: 0 }
+  effort.day: { type: integer, input: true, default: 0, min: 0 }
+  # Effort gained by torching, which lasts for the scene.
+  effort.torched: { type: integer, input: true, default: 0, min: 0 }
+  # Effort Committed for as long as a technique lasts, held on the technique: its copy, the
+  # pick that chose it, or the grant of a core technique. Each technique adds its own.
+  effort.active: { type: integer, formula: 0 }
+  effort.available:
+    type: integer
+    formula: max(0, effort.max + effort.torched - effort.scene - effort.day - effort.active)
+
+effects:
+  - target: { rolls: [attack, damage] }
+    op: rollModifier
+    value: { kind: advantage, of: roll }
+    when: >-
+      has(participants.target) && size(participants.target) > 0
+        && participants.target[0].psionics.cursedLuck
+
+  # When the scene ends, torched Effort goes, and with it the techniques it sustained.
+  - target: { steps: [rest.scene, rest.night] }
+    op: changes
+    value:
+      changes:
+        - type: adjustState
+          when: "countCopies(copy.type == 'technique' && copy.state.torched > 0) > 0"
+          copies: { type: technique, where: self.torched > 0 }
+          key: committed
+          by: -self.torched
+        - type: setState
+          when: "countCopies(copy.type == 'technique' && copy.state.torched > 0) > 0"
+          copies: { type: technique, where: self.torched > 0 }
+          key: torched
+          value: 0
+        - type: adjustState
+          when: "countPicks(pick.type == 'technique' && pick.state.torched > 0) > 0"
+          picks: { where: self.torched > 0 }
+          key: committed
+          by: -self.torched
+        - type: setState
+          when: "countPicks(pick.type == 'technique' && pick.state.torched > 0) > 0"
+          picks: { where: self.torched > 0 }
+          key: torched
+          value: 0
+        - type: adjustState
+          when: "countGrants(grant.type == 'technique' && grant.state.torched > 0) > 0"
+          grants: { where: self.torched > 0 }
+          key: committed
+          by: -self.torched
+        - type: setState
+          when: "countGrants(grant.type == 'technique' && grant.state.torched > 0) > 0"
+          grants: { where: self.torched > 0 }
+          key: torched
+          value: 0
+
+contentTypes:
+  technique:
+    copies: { perItem: 1 }
+    fields:
+      discipline:
+        type: enum
+        open: true
+        required: true
+        values: [biopsionics, metapsionics, precognition, telekinesis, telepathy, teleportation]
+      level: { type: integer, required: true, min: 0, max: 4 }
+      # The discipline's core technique: every psychic with the skill has it.
+      core: { type: boolean, default: false }
+    state:
+      # Effort Committed to keep the technique going, until it is released.
+      committed: { type: integer, default: 0, min: 0 }
+      # The part of it torched Effort pays for, which ends with the scene.
+      torched: { type: integer, default: 0, min: 0 }
+    effects:
+      - { target: effort.active, op: add, value: self.committed }
+    actions:
+      - use: sustain-technique
+      - use: release-technique
+
+constraints:
+  # Only psychics have psychic skills, and a restricted psychic only their one discipline.
+  - id: psychic-skills
+    check: >-
+      psionics.access == 'unrestricted'
+        || sumFields(f.value >= 0 && (psionics.access == 'none' || psionics.discipline == 'none'
+          || f.id != fieldId('skills.{psychic}.level', psionics.discipline)) ? 1 : 0,
+          'skill.psychic' in f.tags) == 0
+  # Torching can lower the maximum under what is Committed; the commitments stay until released.
+  - id: effort-overcommitted
+    check: effort.max + effort.torched - effort.scene - effort.day - effort.active >= 0
+
+actions:
+  # Commit a point of Effort for as long as the technique lasts: it stays Committed on the
+  # technique until the psychic releases it, ending the power.
+  - id: sustain-technique
+    tags: [psionics]
+    available: effort.available > 0
+    results: [committed]
+    steps:
+      - &held
+        id: held
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              # Where the technique is held: its own copy, a focus's pick (Wild Psychic Talent)
+              # or a psychic class's grant (a core technique). The owning copy's type tells.
+              held: >-
+                countCopies(copy.id == self.id && copy.type == 'technique') > 0 ? 'copy'
+                  : countCopies(copy.id == self.id && copy.type == 'focus') > 0 ? 'pick'
+                  : 'grant'
+              torched: effort.max - effort.scene - effort.day - effort.active <= 0
+      - id: commit
+        kind: changes
+        changes:
+          - { type: adjustState, when: "flags.held == 'copy'", entry: self, key: committed, by: 1 }
+          - { type: adjustState, when: "flags.held == 'pick'", pick: self, key: committed, by: 1 }
+          - { type: adjustState, when: "flags.held == 'grant'", grant: self, key: committed, by: 1 }
+          - type: adjustState
+            when: "flags.torched && flags.held == 'copy'"
+            entry: self
+            key: torched
+            by: 1
+          - type: adjustState
+            when: "flags.torched && flags.held == 'pick'"
+            pick: self
+            key: torched
+            by: 1
+          - type: adjustState
+            when: "flags.torched && flags.held == 'grant'"
+            grant: self
+            key: torched
+            by: 1
+      - { id: result, kind: outcome, result: "'committed'" }
+
+  # Reclaim the Effort a technique holds, ending it.
+  - id: release-technique
+    tags: [psionics]
+    available: self.committed > 0
+    results: [released]
+    steps:
+      - *held
+      - id: release
+        kind: changes
+        changes:
+          - { type: setState, when: "flags.held == 'copy'", entry: self, key: committed, value: 0 }
+          - { type: setState, when: "flags.held == 'pick'", pick: self, key: committed, value: 0 }
+          - { type: setState, when: "flags.held == 'grant'", grant: self, key: committed, value: 0 }
+          - { type: setState, when: "flags.held == 'copy'", entry: self, key: torched, value: 0 }
+          - { type: setState, when: "flags.held == 'pick'", pick: self, key: torched, value: 0 }
+          - { type: setState, when: "flags.held == 'grant'", grant: self, key: torched, value: 0 }
+      - { id: result, kind: outcome, result: "'released'" }