@opencharacter/swn-revised 0.0.0-stage → 0.2.0

package/rules/creation.yaml

@@ -0,0 +1,431 @@
+# Two ways to start: the full procedure (attributes rolled or from the array, a background with
+# its skills picked, taken as quick skills or rolled, a class, foci and a hobby skill) and the
+# quick tables (class and style, background, psychic disciplines, foci and bonus skill, each
+# rolled or picked). The quick tables are the book's random creation.
+creation:
+  - { id: standard, action: create-character }
+  - { id: quick, action: quick-character }
+  - { id: random, action: quick-character, params: { random: true }, random: true }
+
+actions:
+  # One skill pick at creation: a skill's first pick is level-0, the second level-1, and a third
+  # is any other non-psychic skill below level-1. Also the attribute picks of the Growth table.
+  - id: gain-skill
+    available: character.creating
+    tags: [creation]
+    params:
+      entry:
+        {
+          type: enum,
+          open: true,
+          required: true,
+          values:
+            [
+              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,
+              any-combat,
+              any-skill,
+              stab-or-shoot,
+              shoot-or-trade,
+              punch-or-stab,
+              any-psychic,
+              raise-zero,
+              any-stat,
+              physical,
+              mental,
+              none,
+            ],
+        }
+      random: { type: boolean, default: false }
+    results: [gained]
+    steps:
+      - id: start
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              stat: "params.entry in ['any-stat', 'physical', 'mental']"
+              pool: >-
+                params.entry == 'any-combat' ? ['punch', 'shoot', 'stab']
+                  : params.entry == 'stab-or-shoot' ? ['stab', 'shoot']
+                  : params.entry == 'shoot-or-trade' ? ['shoot', 'trade']
+                  : params.entry == 'punch-or-stab' ? ['punch', 'stab']
+                  : params.entry == 'any-psychic' ? keysOf('psychic')
+                  : params.entry == 'any-skill' ? keysOf('general') + keysOf('combat')
+                  : params.entry == 'raise-zero'
+                    ? filterList(keysOf('general') + keysOf('combat'),
+                      fieldOf('skills.{skill}.level', x) == 0)
+                  : params.entry in keysOf('skill') ? [params.entry] : []
+              str: 0
+              dex: 0
+              con: 0
+              int: 0
+              wis: 0
+              cha: 0
+      - id: candidates
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              open: >-
+                flags.stat || params.entry == 'none' ? []
+                  : countList(flags.pool, fieldOf('skills.{skill}.level', x) < 1) > 0
+                    ? filterList(flags.pool, fieldOf('skills.{skill}.level', x) < 1)
+                  : filterList(keysOf('general') + keysOf('combat'),
+                    fieldOf('skills.{skill}.level', x) < 1)
+      - id: choose
+        kind: choice
+        when: size(flags.open) > 1
+        random: params.random
+        recommend: flags.open[0]
+        options: { values: { formula: flags.open } }
+      - id: picked
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              skill: "size(flags.open) == 1 ? flags.open[0] : has(steps.choose) ? steps.choose.picked : ''"
+      - id: gain
+        kind: changes
+        when: flags.skill != ''
+        changes:
+          - {
+              type: adjust,
+              field: { formula: "fieldId('skills.{skill}.level', flags.skill)" },
+              by: 1,
+            }
+      # A psychic skill raised to level-1 brings a level-1 technique of its discipline.
+      - id: technique
+        kind: choice
+        sheet: proposed
+        when: "flags.skill in keysOf('psychic') && fieldOf('skills.{psychic}.level', flags.skill) >= 1"
+        random: params.random
+        recommend: options[0]
+        options:
+          content:
+            type: technique
+            where: >-
+              item.discipline == flags.skill && !item.core
+                && item.level <= fieldOf('skills.{psychic}.level', flags.skill)
+                && countCopies(copy.item == item.id) == 0
+        changes:
+          - { type: addItem, entry: { item: picked.id } }
+      # +1 to any attribute below 18, or one of the +2 pairs of the physical or mental ones.
+      - id: attribute
+        kind: choice
+        sheet: proposed
+        when: "params.entry == 'any-stat'"
+        random: params.random
+        recommend: options[0]
+        options:
+          values:
+            { formula: "filterList(keysOf('attr'), fieldOf('attributes.{attr}.score', x) < 18)" }
+        changes:
+          - type: set
+            field: { formula: "'attributes.' + picked.value + '.score'" }
+            value: "fieldOf('attributes.{attr}.score', picked.value) + 1"
+      - id: pair
+        kind: choice
+        sheet: proposed
+        when: "params.entry in ['physical', 'mental']"
+        random: params.random
+        recommend: options[0]
+        options:
+          - { id: str2, when: "params.entry == 'physical'", flags: { str: 2 } }
+          - { id: dex2, when: "params.entry == 'physical'", flags: { dex: 2 } }
+          - { id: con2, when: "params.entry == 'physical'", flags: { con: 2 } }
+          - { id: str-dex, when: "params.entry == 'physical'", flags: { str: 1, dex: 1 } }
+          - { id: str-con, when: "params.entry == 'physical'", flags: { str: 1, con: 1 } }
+          - { id: dex-con, when: "params.entry == 'physical'", flags: { dex: 1, con: 1 } }
+          - { id: int2, when: "params.entry == 'mental'", flags: { int: 2 } }
+          - { id: wis2, when: "params.entry == 'mental'", flags: { wis: 2 } }
+          - { id: cha2, when: "params.entry == 'mental'", flags: { cha: 2 } }
+          - { id: int-wis, when: "params.entry == 'mental'", flags: { int: 1, wis: 1 } }
+          - { id: int-cha, when: "params.entry == 'mental'", flags: { int: 1, cha: 1 } }
+          - { id: wis-cha, when: "params.entry == 'mental'", flags: { wis: 1, cha: 1 } }
+      - id: raise
+        kind: changes
+        sheet: proposed
+        when: has(steps.pair)
+        changes:
+          - type: set
+            when: flags.str > 0
+            field: attributes.str.score
+            value: 'min(18, attributes.str.score + flags.str)'
+          - type: set
+            when: flags.dex > 0
+            field: attributes.dex.score
+            value: 'min(18, attributes.dex.score + flags.dex)'
+          - type: set
+            when: flags.con > 0
+            field: attributes.con.score
+            value: 'min(18, attributes.con.score + flags.con)'
+          - type: set
+            when: flags.int > 0
+            field: attributes.int.score
+            value: 'min(18, attributes.int.score + flags.int)'
+          - type: set
+            when: flags.wis > 0
+            field: attributes.wis.score
+            value: 'min(18, attributes.wis.score + flags.wis)'
+          - type: set
+            when: flags.cha > 0
+            field: attributes.cha.score
+            value: 'min(18, attributes.cha.score + flags.cha)'
+      - id: result
+        kind: outcome
+        result: "'gained'"
+        data: { skill: flags.skill }
+
+  # A focus level: a new focus, or the next level of one already held. A new focus's bonus skill
+  # is a skill pick at creation and three skill points on advancement.
+  - id: gain-focus
+    listed: false
+    tags: [creation, level-up]
+    params:
+      kind: { type: enum, values: [any, combat, noncombat], default: any }
+      advancement: { type: boolean, default: false }
+      random: { type: boolean, default: false }
+    results: [gained]
+    steps:
+      - id: focus
+        kind: choice
+        tags: [{ formula: "params.advancement ? 'level-up.focus' : 'creation.focus'" }]
+        sheet: proposed
+        random: params.random
+        recommend: options[0]
+        options:
+          content:
+            type: focus
+            where: >-
+              (params.kind == 'any' || item.kind == params.kind)
+                && !('needs-psionics' in item.tags && psionics.access == 'none')
+                && !('no-psionics' in item.tags && psionics.access != 'none')
+                && (item.repeatable || countCopies(copy.item == item.id
+                  && copy.state.level >= item.maxLevel) == 0)
+        changes:
+          - type: adjustState
+            when: >-
+              has(picked.item) && !picked.item.repeatable
+                && countCopies(copy.item == picked.id) > 0
+            copies: { type: focus, where: item.id == steps.focus.picked }
+            limit: 1
+            key: level
+            by: 1
+          - type: addItem
+            when: >-
+              has(picked.item)
+                && (picked.item.repeatable || countCopies(copy.item == picked.id) == 0)
+            entry: { item: picked.id }
+      - id: picks
+        kind: choice
+        sheet: proposed
+        when: size(steps.focus.added) > 0
+        random: params.random
+        options: { pending: { entry: 'steps.focus.added[0]' } }
+      - id: bonus
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              entry: >-
+                size(steps.focus.added) == 0 ? 'none'
+                  : steps.focus.item.skill != 'chosen' ? steps.focus.item.skill
+                  : size(steps.picks.picked) > 0 ? steps.picks.picked[0] : 'any-skill'
+      - id: skill
+        kind: action
+        when: "!params.advancement && flags.entry != 'none'"
+        use: gain-skill
+        params: { entry: flags.entry, random: params.random }
+      - id: points
+        kind: action
+        when: "params.advancement && flags.entry != 'none'"
+        use: focus-skill-points
+        params: { entry: flags.entry, random: params.random }
+      - { id: result, kind: outcome, result: "'gained'" }
+
+  - id: starting-gear
+    available: character.creating
+    tags: [creation]
+    params:
+      random: { type: boolean, default: false }
+    results: [equipped]
+    steps:
+      # A package (an add-on pack's too), or credits instead: the class's own package is
+      # recommended. The package's own action adds its gear and credits.
+      - id: kit
+        tags: [creation.kit]
+        kind: choice
+        sheet: proposed
+        random: params.random
+        options: { content: { type: kit } }
+        prefer: "countCopies(copy.type == 'class' && copy.fields.kit == item.id)"
+        changes:
+          - type: addItem
+            when: has(picked.item)
+            entry: { id: kit, item: picked.id }
+      - id: unpack
+        kind: action
+        when: has(steps.kit.item)
+        sheet: proposed
+        entry: "'kit'"
+        use: unpack
+      - id: unpacked
+        kind: changes
+        when: has(steps.kit.item)
+        changes:
+          - { type: removeItem, entry: kit }
+      # A kit may ready more than half Strength. Readied gear, then all but one weapon (the
+      # weakest first), are stowed while they fit within Strength. Past that, readied gear, a
+      # shield, the last weapon and then armor are stowed anyway, and Stowed gear, weapons and
+      # armor past Strength are left behind (the heaviest first), so play starts unencumbered.
+      - id: stowGear
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: gear
+            where: >-
+              self.equipped && has(item.enc) && item.enc > 0
+                && encumbrance.readied > encumbrance.readiedLimit
+                && encumbrance.stowed + item.enc * ceil(self.quantity / item.bundle)
+                  <= encumbrance.stowedLimit
+        prefer: item.enc
+        changes:
+          - { type: equip, entry: picked, equipped: false }
+      - id: stowWeapon
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: weapon
+            where: >-
+              self.equipped && has(item.enc) && item.enc > 0
+                && countCopies(copy.type == 'weapon' && copy.equipped && has(copy.fields.enc)
+                  && copy.fields.enc > 0) > 1
+                && encumbrance.readied > encumbrance.readiedLimit
+                && encumbrance.stowed + item.enc * ceil(self.quantity / item.bundle)
+                  <= encumbrance.stowedLimit
+        prefer: -maxOf(item.damage)
+        changes:
+          - { type: equip, entry: picked, equipped: false }
+      - id: stowGearOver
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: gear
+            where: >-
+              self.equipped && has(item.enc) && item.enc > 0
+                && encumbrance.readied > encumbrance.readiedLimit
+        prefer: item.enc
+        changes:
+          - { type: equip, entry: picked, equipped: false }
+      - id: stowShield
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: armor
+            where: >-
+              self.equipped && has(item.enc) && item.enc > 0 && item.shield
+                && encumbrance.readied > encumbrance.readiedLimit
+        prefer: item.enc
+        changes:
+          - { type: equip, entry: picked, equipped: false }
+      - id: stowLastWeapon
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: weapon
+            where: >-
+              self.equipped && has(item.enc) && item.enc > 0
+                && encumbrance.readied > encumbrance.readiedLimit
+        prefer: -maxOf(item.damage)
+        changes:
+          - { type: equip, entry: picked, equipped: false }
+      - id: stowArmor
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: armor
+            where: >-
+              self.equipped && has(item.enc) && item.enc > 0
+                && encumbrance.readied > encumbrance.readiedLimit
+        prefer: item.enc
+        changes:
+          - { type: equip, entry: picked, equipped: false }
+      - id: dropGear
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: gear
+            where: >-
+              !self.equipped && !self.stored && has(item.enc) && item.enc > 0
+                && encumbrance.stowed > encumbrance.stowedLimit
+        prefer: 'item.enc * ceil(self.quantity / item.bundle)'
+        changes:
+          - { type: removeItem, entry: picked }
+      - id: dropWeapon
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: weapon
+            where: >-
+              !self.equipped && !self.stored && has(item.enc) && item.enc > 0
+                && encumbrance.stowed > encumbrance.stowedLimit
+        prefer: 'item.enc * ceil(self.quantity / item.bundle)'
+        changes:
+          - { type: removeItem, entry: picked }
+      - id: dropArmor
+        kind: choice
+        sheet: proposed
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: armor
+            where: >-
+              !self.equipped && !self.stored && has(item.enc) && item.enc > 0
+                && encumbrance.stowed > encumbrance.stowedLimit
+        prefer: 'item.enc * ceil(self.quantity / item.bundle)'
+        changes:
+          - { type: removeItem, entry: picked }
+      - { id: result, kind: outcome, result: "'equipped'" }

package/rules/gear.yaml

@@ -0,0 +1,188 @@
+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:
+  # A starting package: its own `unpack` action adds its gear and sets the credits.
+  kit:
+    carried: false
+
+  weapon:
+    carried: true
+    equippable: true
+    fields:
+      damage: { type: dice, required: true }
+      skill: { type: enum, values: [punch, shoot, stab], required: true, open: 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], open: true }
+      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 }
+      # Rounds in the magazine of a weapon that has one.
+      loaded:
+        type: integer
+        min: 0
+        max: 'has(item.magazine) ? item.magazine : 0'
+        default: 'has(item.magazine) ? item.magazine : 0'
+    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, open: 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
+        open: 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], open: true }
+      # 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