@opencharacter/swn-revised 0.0.0-stage → 0.1.0

package/rules/advancement.yaml

@@ -0,0 +1,461 @@
+fields:
+  # Unspent skill points: any skill; non-combat, non-psychic skills only (Expert); psychic skills
+  # and techniques only (a psychic's point each level); the Psychic Training discipline only.
+  skillPoints.general: { type: integer, input: true, default: 0, min: 0 }
+  skillPoints.expert: { type: integer, input: true, default: 0, min: 0 }
+  skillPoints.psychic: { type: integer, input: true, default: 0, min: 0 }
+  skillPoints.training: { type: integer, input: true, default: 0, min: 0 }
+  # A focus's bonus skill points that didn't buy a level, saved toward that skill only.
+  'skills.{skill}.credit': { type: integer, input: true, default: 0, min: 0, max: 4 }
+  # Attribute boosts bought with skill points, at most five.
+  attributes.boosts: { type: integer, input: true, default: 0, min: 0, max: 5 }
+
+followUps:
+  - id: level-up
+    while: '!character.creating && level < 10 && xp.current >= xp.next'
+    action: level-up
+
+actions:
+  # A new level: hit points rolled again, three skill points (one of them psychic for a psychic,
+  # plus the Expert's bonus point), and a focus level at 2nd, 5th, 7th and 10th level. Saving
+  # throws and the attack bonus follow the level.
+  - id: level-up
+    tags: [level-up]
+    available: '!character.creating && level < 20'
+    results: [advanced]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              before: hp.max
+              next: level + 1
+              trained: countCopies(copy.item == @foci.psychic-training && copy.state.level >= 2) > 0
+      - id: level
+        kind: changes
+        changes:
+          - { type: set, field: level, value: flags.next }
+      # The new level's d6, Constitution added to each (none below 1). The new maximum is the
+      # total with the per-level bonuses if that is more, else one more than before.
+      - id: hp
+        kind: roll
+        tags: [level-up]
+        parts: [{ dice: (flags.next)d6 }]
+      - id: maximum
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              total: >-
+                sumList(steps.hp.faces, max(1, x + attributes.con.mod)) + hp.perLevel * level
+      - id: hitPoints
+        kind: changes
+        sheet: proposed
+        changes:
+          - type: set
+            field: hp.rolled
+            value: '(flags.total > flags.before ? flags.total : flags.before + 1) - hp.perLevel * level'
+          - type: adjust
+            field: hp.current
+            by: '(flags.total > flags.before ? flags.total : flags.before + 1) - flags.before'
+            tags: [healing]
+      - id: focus
+        kind: action
+        when: flags.next in [2, 5, 7, 10]
+        use: gain-focus
+        params: { advancement: true }
+      # Psychic Training's second level: a point each level, and the levels before it when it is
+      # taken late.
+      - id: points
+        kind: changes
+        sheet: proposed
+        changes:
+          - { type: adjust, field: skillPoints.general, by: "psionics.access == 'none' ? 3 : 2" }
+          - { type: adjust, field: skillPoints.psychic, by: 1, when: "psionics.access != 'none'" }
+          - {
+              type: adjust,
+              field: skillPoints.expert,
+              by: class.expertPoints,
+              when: class.expertPoints > 0,
+            }
+          - type: adjust
+            when: >-
+              countCopies(copy.item == @foci.psychic-training && copy.state.level >= 2) > 0
+            field: skillPoints.training
+            by: 'flags.trained ? 1 : flags.next - 1'
+      - { id: result, kind: outcome, result: "'advanced'" }
+
+  # A focus's bonus skill taken on advancement: three skill points toward it, with any credit
+  # already saved toward it, buying levels in order (level-0 costs 1, level-1 2 and so on). What
+  # doesn't buy a level is saved as credit toward the skill; on a skill at level-4 it goes to the
+  # general pool.
+  - id: focus-skill-points
+    tags: [level-up]
+    params:
+      entry:
+        type: enum
+        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,
+            punch-or-stab,
+            any-psychic,
+            any-skill,
+          ]
+      random: { type: boolean, default: false }
+    results: [spent]
+    steps:
+      - id: start
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              open: >-
+                params.entry == 'any-combat' ? ['punch', 'shoot', 'stab']
+                  : params.entry == 'punch-or-stab' ? ['punch', 'stab']
+                  : params.entry == 'any-psychic'
+                    ? filterList(keysOf('psychic'), psionics.access == 'unrestricted'
+                      || x == psionics.discipline)
+                  : params.entry == 'any-skill' ? keysOf('general') + keysOf('combat')
+                  : [params.entry]
+      - 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
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              skill: 'size(flags.open) == 1 ? flags.open[0] : steps.choose.picked'
+              from: "fieldOf('skills.{skill}.level', size(flags.open) == 1 ? flags.open[0] : steps.choose.picked)"
+              pool: >-
+                3 + fieldOf('skills.{skill}.credit',
+                  size(flags.open) == 1 ? flags.open[0] : steps.choose.picked)
+      - id: level
+        kind: branch
+        cases:
+          - when: true
+            flags: { level: flags.from, had: flags.pool - 3 }
+      - id: buy1
+        kind: branch
+        when: 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.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.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
+        changes:
+          - type: set
+            when: flags.level != flags.from
+            field: { formula: "'skills.' + flags.skill + '.level'" }
+            value: flags.level
+          - type: set
+            when: '(flags.level >= 4 ? 0 : flags.pool) != flags.had'
+            field: { formula: "'skills.' + flags.skill + '.credit'" }
+            value: 'flags.level >= 4 ? 0 : flags.pool'
+          - type: adjust
+            when: flags.level >= 4 && flags.pool > 0
+            field: skillPoints.general
+            by: flags.pool
+      # A free technique for each new psychic skill level from level-1 up.
+      - id: technique
+        kind: action
+        when: flags.skill in keysOf('psychic') && flags.level >= 1 && flags.level > flags.from
+        use: pick-technique
+        params: { discipline: flags.skill, random: params.random }
+      - id: technique2
+        kind: action
+        when: flags.skill in keysOf('psychic') && flags.level >= 2 && flags.level - flags.from >= 2
+        use: pick-technique
+        params: { discipline: flags.skill, random: params.random }
+      - { id: result, kind: outcome, result: "'spent'", data: { skill: flags.skill } }
+
+  # A technique of the discipline at or below its skill level, free with a new skill level.
+  - id: pick-technique
+    tags: [level-up]
+    params:
+      discipline:
+        type: enum
+        required: true
+        values: [biopsionics, metapsionics, precognition, telekinesis, telepathy, teleportation]
+      random: { type: boolean, default: false }
+    results: [picked]
+    steps:
+      - id: technique
+        kind: choice
+        sheet: proposed
+        random: params.random
+        recommend: options[0]
+        options:
+          content:
+            type: technique
+            where: >-
+              item.discipline == params.discipline && !item.core
+                && item.level <= fieldOf('skills.{psychic}.level', params.discipline)
+                && countCopies(copy.item == item.id) == 0
+        changes:
+          - { type: addItem, entry: { item: picked.id } }
+      - { id: result, kind: outcome, result: "'picked'" }
+
+  # Spend skill points on a skill's next level. Each level costs its number plus one, and the
+  # higher levels need a character level: level-2 at 3rd, level-3 at 6th, level-4 at 9th.
+  - id: raise-skill
+    tags: [level-up]
+    available: '!character.creating'
+    params:
+      skill:
+        type: enum
+        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,
+          ]
+    results: [raised, refused]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              from: "fieldOf('skills.{skill}.level', params.skill)"
+              credit: "fieldOf('skills.{skill}.credit', params.skill)"
+              psychic: params.skill in keysOf('psychic')
+              general: params.skill in keysOf('general')
+      # Credit saved toward the skill pays first.
+      - id: cost
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              fromCredit: min(flags.from + 2, flags.credit)
+              cost: flags.from + 2 - min(flags.from + 2, flags.credit)
+      - id: training
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              training: >-
+                params.skill == psionics.training ? min(flags.cost, skillPoints.training) : 0
+      - id: pools
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              fromPsychic: 'flags.psychic ? min(flags.cost - flags.training, skillPoints.psychic) : 0'
+              fromExpert: 'flags.general ? min(flags.cost - flags.training, skillPoints.expert) : 0'
+      - id: check
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              fromGeneral: flags.cost - flags.training - flags.fromPsychic - flags.fromExpert
+              allowed: >-
+                flags.from < 4 && level >= [1, 1, 3, 6, 9][flags.from + 1]
+                  && (!flags.psychic || psionics.access == 'unrestricted'
+                    || (psionics.access == 'restricted' && params.skill == psionics.discipline))
+      - id: pay
+        kind: changes
+        when: flags.allowed && flags.fromGeneral <= skillPoints.general
+        changes:
+          - type: adjust
+            when: flags.fromCredit > 0
+            field: { formula: "'skills.' + params.skill + '.credit'" }
+            by: -flags.fromCredit
+          - {
+              type: adjust,
+              field: skillPoints.training,
+              by: -flags.training,
+              when: flags.training > 0,
+            }
+          - {
+              type: adjust,
+              field: skillPoints.psychic,
+              by: -flags.fromPsychic,
+              when: flags.fromPsychic > 0,
+            }
+          - {
+              type: adjust,
+              field: skillPoints.expert,
+              by: -flags.fromExpert,
+              when: flags.fromExpert > 0,
+            }
+          - {
+              type: adjust,
+              field: skillPoints.general,
+              by: -flags.fromGeneral,
+              when: flags.fromGeneral > 0,
+            }
+          - { type: adjust, field: { formula: "'skills.' + params.skill + '.level'" }, by: 1 }
+      - id: technique
+        kind: action
+        when: >-
+          flags.psychic && flags.allowed && flags.fromGeneral <= skillPoints.general
+            && flags.from >= 0
+        use: pick-technique
+        params: { discipline: params.skill }
+      - id: result
+        kind: outcome
+        result: "flags.allowed && flags.fromGeneral <= skillPoints.general ? 'raised' : 'refused'"
+
+  # Spend skill points on a technique: as many as its level.
+  - id: learn-technique
+    tags: [level-up]
+    available: "!character.creating && psionics.access != 'none'"
+    params:
+      technique: { type: id, of: technique, required: true, where: '!item.core' }
+    results: [learned, refused]
+    steps:
+      - id: start
+        kind: choice
+        options: { content: { type: technique, where: item.id == params.technique } }
+        recommend: options[0]
+      - id: cost
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              cost: steps.start.item.level
+              training: >-
+                steps.start.item.discipline == psionics.training
+                  ? min(steps.start.item.level, skillPoints.training) : 0
+      - id: pools
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              fromPsychic: min(flags.cost - flags.training, skillPoints.psychic)
+      - id: check
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              fromGeneral: flags.cost - flags.training - flags.fromPsychic
+              allowed: >-
+                countCopies(copy.item == params.technique) == 0
+                  && fieldOf('skills.{psychic}.level', steps.start.item.discipline)
+                    >= steps.start.item.level
+      - id: pay
+        kind: changes
+        when: flags.allowed && flags.fromGeneral <= skillPoints.general
+        changes:
+          - {
+              type: adjust,
+              field: skillPoints.training,
+              by: -flags.training,
+              when: flags.training > 0,
+            }
+          - {
+              type: adjust,
+              field: skillPoints.psychic,
+              by: -flags.fromPsychic,
+              when: flags.fromPsychic > 0,
+            }
+          - {
+              type: adjust,
+              field: skillPoints.general,
+              by: -flags.fromGeneral,
+              when: flags.fromGeneral > 0,
+            }
+          - { type: addItem, entry: { item: params.technique } }
+      - id: result
+        kind: outcome
+        result: "flags.allowed && flags.fromGeneral <= skillPoints.general ? 'learned' : 'refused'"
+
+  # Spend skill points on +1 to an attribute: the first boost costs 1, the second 2 and so on,
+  # the third needs 3rd level, the fourth 6th and the fifth 9th.
+  - id: boost-attribute
+    tags: [level-up]
+    available: '!character.creating && attributes.boosts < 5'
+    params:
+      attribute: { type: enum, required: true, values: [str, dex, con, int, wis, cha] }
+    results: [boosted, refused]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              allowed: >-
+                skillPoints.general >= attributes.boosts + 1
+                  && level >= [1, 1, 3, 6, 9][attributes.boosts]
+                  && fieldOf('attributes.{attr}.score', params.attribute) < 18
+      - id: pay
+        kind: changes
+        when: flags.allowed
+        changes:
+          - { type: adjust, field: skillPoints.general, by: -(attributes.boosts + 1) }
+          - { type: adjust, field: attributes.boosts, by: 1 }
+          - {
+              type: adjust,
+              field: { formula: "'attributes.' + params.attribute + '.score'" },
+              by: 1,
+            }
+      - { id: result, kind: outcome, result: "flags.allowed ? 'boosted' : 'refused'" }

package/rules/character.yaml

@@ -0,0 +1,114 @@
+families:
+  growthRow: [1, 2, 3, 4, 5, 6]
+  learningRow: [1, 2, 3, 4, 5, 6, 7, 8]
+
+fields:
+  # Set by the class and its partial classes.
+  psionics.access: { type: enum, values: [none, restricted, unrestricted], formula: "'none'" }
+  # A restricted psychic's one discipline, picked with the Partial Psychic option.
+  psionics.discipline: { type: string, formula: "''" }
+  # Extra focus levels a new character picks: non-combat (Expert) and combat (Warrior).
+  class.focus.noncombat: { type: integer, formula: 0 }
+  class.focus.combat: { type: integer, formula: 0 }
+  # Extra skill points each level for non-combat, non-psychic skills (Expert).
+  class.expertPoints: { type: integer, formula: 0 }
+  # Spent for the scene: the Expert's reroll and the Warrior's luck.
+  scene.expertReroll: { type: boolean, input: true, default: false }
+  scene.warriorLuck: { type: boolean, input: true, default: false }
+
+contentTypes:
+  class:
+    copies: { max: 1 }
+  # Picked, two of them, by the Adventurer.
+  partialClass:
+    copies: { max: 0 }
+  background:
+    copies: { max: 1 }
+    fields:
+      freeSkill:
+        type: enum
+        required: true
+        values:
+          &entries [
+            administer,
+            connect,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            pilot,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            any-combat,
+            any-skill,
+            stab-or-shoot,
+            shoot-or-trade,
+            any-stat,
+            physical,
+            mental,
+          ]
+      # The quick skills besides the free one.
+      quick1: { type: enum, required: true, values: *entries }
+      quick2: { type: enum, required: true, values: *entries }
+      'growth{growthRow}': { type: enum, required: true, values: *entries }
+      'learning{learningRow}': { type: enum, required: true, values: *entries }
+  focus:
+    fields:
+      kind: { type: enum, values: [combat, noncombat, psychic, special], required: true }
+      # The bonus skill its first level gives; `chosen` is the skill the focus's own choice names.
+      skill:
+        type: enum
+        default: none
+        values:
+          [
+            administer,
+            connect,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            pilot,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            any-combat,
+            punch-or-stab,
+            chosen,
+            none,
+          ]
+      maxLevel: { type: integer, default: 2, min: 1 }
+      # Taken more than once, each time for something else.
+      repeatable: { type: boolean, default: false }
+    state:
+      level: { type: integer, default: 1, min: 1, max: item.maxLevel }
+
+constraints:
+  - id: creation-class-background
+    check: >-
+      !character.creating || (countCopies(copy.type == 'class') > 0
+        && countCopies(copy.type == 'background') > 0)
+  - id: creation-skill-cap
+    check: "!character.creating || maxFields(f.value, 'skill' in f.tags) <= 1"
+    data: { limit: 1 }
+  - id: focus-once
+    copies: { type: focus, where: '!item.repeatable' }
+    check: countCopies(copy.item == item.id) <= 1