@opencharacter/swn-revised 0.0.0-stage → 0.1.0

package/rules/gear.yaml

@@ -0,0 +1,176 @@
+fields:
+  # Armor Class: the best armor worn (or an innate AC), a shield, and Dexterity.
+  ac.innate: { type: integer, formula: 0 }
+  ac.armor:
+    type: integer
+    formula: >-
+      max(10, ac.innate, maxCopies(copy.fields.ac, copy.type == 'armor' && copy.equipped
+        && !copy.fields.shield))
+  ac.shield:
+    type: integer
+    formula: "maxCopies(copy.fields.ac, copy.type == 'armor' && copy.equipped && copy.fields.shield)"
+  ac.value:
+    type: integer
+    tags: [ac]
+    formula: >-
+      (ac.shield > 0 ? (ac.armor >= ac.shield ? ac.armor + 1 : ac.shield) : ac.armor)
+        + attributes.dex.mod
+  # Against firearms and advanced melee weapons, primitive armor and shields count as AC 10.
+  ac.advanced:
+    type: integer
+    tags: [ac]
+    formula: >-
+      max(10, ac.innate, maxCopies(copy.fields.ac, copy.type == 'armor' && copy.equipped
+        && !copy.fields.shield && copy.fields.category != 'primitive'))
+        + (maxCopies(copy.fields.ac, copy.type == 'armor' && copy.equipped && copy.fields.shield
+          && copy.fields.category != 'primitive') > 0 ? 1 : 0)
+        + attributes.dex.mod
+
+  # Damage bonuses from foci: the Stab skill to melee and thrown weapons (Armsman), the Shoot skill
+  # to ranged ones (Gunslinger).
+  damage.melee: { type: integer, formula: 0 }
+  damage.ranged: { type: integer, formula: 0 }
+  shock.bonus: { type: integer, formula: 0 }
+  # Melee Shock that treats every target as AC 10 (Shocking Assault, Close Combatant).
+  shock.anyAc: { type: boolean, formula: false }
+  # Unmodified damage on a miss (Armsman, Gunslinger, Unarmed Combatant).
+  miss.melee: { type: dice, formula: 0 }
+  miss.ranged: { type: dice, formula: 0 }
+  miss.punch: { type: dice, formula: 0 }
+  # Primitive melee weapons and fists that count as advanced (Armsman, Unarmed Combatant).
+  combat.meleeAdvanced: { type: boolean, formula: false }
+  combat.punchAdvanced: { type: boolean, formula: false }
+
+  # Encumbrance: Readied (equipped) items up to half Strength, Stowed items up to Strength.
+  encumbrance.strength: { type: integer, formula: attributes.str.score }
+  encumbrance.readied:
+    type: integer
+    formula: >-
+      sumCopies(copy.fields.enc * ceil(copy.quantity / copy.fields.bundle), has(copy.fields.enc)
+        && copy.equipped && !copy.state.stored)
+  encumbrance.stowed:
+    type: integer
+    formula: >-
+      sumCopies(copy.fields.enc * ceil(copy.quantity / copy.fields.bundle), has(copy.fields.enc)
+        && !copy.equipped && !copy.state.stored)
+  encumbrance.readiedLimit: { type: integer, formula: floor(encumbrance.strength / 2) }
+  encumbrance.stowedLimit: { type: integer, formula: encumbrance.strength }
+  # 0 unencumbered, 1 lightly (2 more Readied or 4 more Stowed), 2 heavily (as much again),
+  # 3 more than that.
+  encumbrance.level:
+    type: integer
+    limits: { max: 2 }
+    formula: >-
+      max(encumbrance.readied <= encumbrance.readiedLimit ? 0
+          : encumbrance.readied <= encumbrance.readiedLimit + 2 ? 1
+          : encumbrance.readied <= encumbrance.readiedLimit + 4 ? 2 : 3,
+        encumbrance.stowed <= encumbrance.stowedLimit ? 0
+          : encumbrance.stowed <= encumbrance.stowedLimit + 4 ? 1
+          : encumbrance.stowed <= encumbrance.stowedLimit + 8 ? 2 : 3)
+  movement: { type: integer, formula: '[10, 7, 5, 0][encumbrance.level]' }
+
+  # System Strain: permanent from cyberware, the rest temporary. It may not pass Constitution.
+  strain.permanent:
+    type: integer
+    formula: "sumCopies(copy.fields.strain, copy.type == 'cyberware' && has(copy.fields.strain))"
+  strain.current: { type: integer, input: true, default: 0, min: 0 }
+  strain.total:
+    type: integer
+    formula: strain.permanent + strain.current
+    limits: { max: strain.max }
+  strain.max: { type: integer, formula: attributes.con.score }
+
+standardCopies:
+  - { type: weapon, where: "'unarmed' in item.tags" }
+
+contentTypes:
+  weapon:
+    carried: true
+    equippable: true
+    fields:
+      damage: { type: dice, required: true }
+      skill: { type: enum, values: [punch, shoot, stab], required: true }
+      attribute: { type: enum, values: [str, dex, str-dex] }
+      range: { type: integer, min: 0 }
+      maxRange: { type: integer, min: 0 }
+      magazine: { type: integer, min: 1 }
+      ammo: { type: enum, values: [rounds, cell-a, cell-b, missile] }
+      shock: { type: integer, min: 0 }
+      shockAc: { type: integer, min: 0 }
+      burst: { type: boolean, default: false }
+      suppress: { type: boolean, default: false }
+      # Energy weapons: +1 to hit.
+      energy: { type: boolean, default: false }
+      # Firearms and TL4 melee weapons ignore primitive armor.
+      advanced: { type: boolean, default: false }
+      heavy: { type: boolean, default: false }
+      thrown: { type: boolean, default: false }
+      nonlethal: { type: boolean, default: false }
+      # Always rolls against this AC (a grenade).
+      fixedAc: { type: integer }
+      reloadActions: { type: integer, default: 1, min: 1 }
+      cost: { type: integer, min: 0 }
+      enc: { type: integer, min: 0 }
+      bundle: { type: integer, default: 1, min: 1 }
+      techLevel: { type: integer, min: 0, max: 6 }
+    state:
+      stored: { type: boolean, default: false }
+    actions:
+      - use: attack
+      - use: reload
+
+  armor:
+    carried: true
+    equippable: true
+    fields:
+      ac: { type: integer, required: true, min: 10 }
+      category: { type: enum, values: [primitive, street, combat, powered], required: true }
+      shield: { type: boolean, default: false }
+      # Strength counted higher for encumbrance while worn.
+      strength: { type: integer, default: 0, min: 0 }
+      cost: { type: integer, min: 0 }
+      enc: { type: integer, min: 0 }
+      bundle: { type: integer, default: 1, min: 1 }
+      techLevel: { type: integer, min: 0, max: 6 }
+    state:
+      stored: { type: boolean, default: false }
+    effects:
+      - target: encumbrance.strength
+        op: add
+        value: item.strength
+        when: self.equipped && item.strength > 0
+
+  gear:
+    carried: true
+    equippable: true
+    fields:
+      category:
+        type: enum
+        required: true
+        values: [ammo-power, communications, computing, field, pharmaceutical, tools-medical]
+      # What a weapon reloads with.
+      kind: { type: enum, values: [rounds, cell-a, cell-b, missile] }
+      # A drug: the Heal skill needed to apply it, the System Strain it adds and what it heals.
+      healSkill: { type: integer, min: 0 }
+      strain: { type: integer, default: 0, min: 0 }
+      heal: { type: dice }
+      healAddsSkill: { type: boolean, default: false }
+      cost: { type: integer, min: 0 }
+      enc: { type: integer, min: 0 }
+      # How many make one item of encumbrance when packed together.
+      bundle: { type: integer, default: 1, min: 1 }
+      techLevel: { type: integer, min: 0, max: 6 }
+    state:
+      stored: { type: boolean, default: false }
+    actions:
+      - use: use-drug
+
+  cyberware:
+    fields:
+      strain: { type: integer, required: true, min: 0 }
+      # System Strain each time it is triggered.
+      activationStrain: { type: integer, default: 0, min: 0 }
+      cost: { type: integer, min: 0 }
+      techLevel: { type: integer, min: 0, max: 6 }
+    actions:
+      - use: trigger-cyberware

package/rules/layout.yaml

@@ -0,0 +1,195 @@
+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 }
+    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 }
+    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 != ''" }
+    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,105 @@
+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: effort.max + effort.torched - effort.scene - effort.day - effort.active
+    limits: { min: 0 }
+
+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
+
+contentTypes:
+  technique:
+    copies: { perItem: 1 }
+    fields:
+      discipline:
+        type: enum
+        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 }
+    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'
+          || f.id != 'swn-revised:skills.' + psionics.discipline + '.level') ? 1 : 0,
+          'skill.psychic' in f.tags) == 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'
+      - 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 }
+      - { 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 }
+      - { id: result, kind: outcome, result: "'released'" }