@opencharacter/wwn-srd 0.0.0-stage → 0.2.0

package/rules/creation-steps.yaml

@@ -0,0 +1,258 @@
+actions:
+  # A background table entry: a skill, `any` or `combat` skill, or `any-stat`, `physical` or
+  # `mental` attribute points.
+  - id: background-entry
+    available: false
+    params:
+      entry: { type: string }
+      random: { type: boolean, default: false }
+    results: [gained]
+    steps:
+      - id: skill
+        kind: action
+        when: "!(params.entry in ['any-stat', 'physical', 'mental'])"
+        use: gain-skill
+        params: { skill: params.entry, random: params.random }
+      - id: attribute
+        kind: action
+        when: "params.entry in ['any-stat', 'physical', 'mental']"
+        use: gain-attributes
+        params: { kind: params.entry, random: params.random }
+      - id: result
+        kind: outcome
+        result: "'gained'"
+
+  # Gaining a skill at creation: level-0, or level-1 if it is already level-0. A skill already
+  # at level-1, or a choice (`any`, `combat`, `punch-stab`, `perform-sneak`, `specialist`), is a
+  # pick among the skills still below level-1; a Focus's pick leaves out Magic.
+  #
+  # With `points` (a Focus gained after first level), the skill gets that many skill points
+  # instead: levels as far as they pay, the rest kept as credit toward the next. A skill at
+  # level-4 sends them to another.
+  - id: gain-skill
+    available: false
+    params:
+      skill: { type: string }
+      random: { type: boolean, default: false }
+      focus: { type: boolean, default: false }
+      points: { type: integer, default: 0, min: 0 }
+    results: [gained]
+    steps:
+      - id: setup
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              cap: 'params.points > 0 ? 4 : 1'
+              direct: >-
+                params.skill in keysOf('skill')
+                  && fieldOf('skills.{skill}', params.skill) < (params.points > 0 ? 4 : 1)
+              allowed: >-
+                params.skill == 'combat' && (skills.stab < 1 || skills.shoot < 1 || skills.punch < 1)
+                    ? ['stab', 'shoot', 'punch']
+                  : params.skill == 'punch-stab' && (skills.punch < 1 || skills.stab < 1)
+                    ? ['punch', 'stab']
+                  : params.skill == 'perform-sneak' && (skills.perform < 1 || skills.sneak < 1)
+                    ? ['perform', 'sneak']
+                  : params.skill == 'specialist'
+                    ? filterList(keysOf('skill'), !(x in ['magic', 'stab', 'shoot', 'punch']))
+                  : params.focus ? filterList(keysOf('skill'), x != 'magic')
+                  : keysOf('skill')
+      - id: pick
+        kind: choice
+        sheet: proposed
+        when: '!flags.direct'
+        random: params.random
+        options:
+          values: { formula: flags.allowed }
+          where: "fieldOf('skills.{skill}', value) < flags.cap"
+        recommend: options[0]
+      - id: target
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: flags.direct || has(steps.pick)
+            flags:
+              target: 'flags.direct ? params.skill : steps.pick.picked'
+              from: "fieldOf('skills.{skill}', flags.direct ? params.skill : steps.pick.picked)"
+              credit: >-
+                fieldOf('skillCredit.{skill}', flags.direct ? params.skill : steps.pick.picked)
+                  + params.points
+      # Skill points: a level costs one more than the level bought.
+      - id: spend
+        kind: branch
+        when: params.points > 0 && has(flags.target)
+        cases:
+          - when: true
+            flags:
+              first: 'flags.credit >= flags.from + 2 ? 1 : 0'
+              left: 'flags.credit >= flags.from + 2 ? flags.credit - flags.from - 2 : flags.credit'
+      - id: spend2
+        kind: branch
+        when: params.points > 0 && has(flags.target)
+        cases:
+          - when: true
+            flags:
+              second: 'flags.from + flags.first < 4 && flags.left >= flags.from + flags.first + 2 ? 1 : 0'
+      - id: raise
+        kind: changes
+        when: has(flags.target)
+        changes:
+          - type: adjust
+            when: params.points == 0
+            field: { formula: "fieldId('skills.{skill}', flags.target)" }
+            by: 1
+          - type: adjust
+            when: params.points > 0 && flags.first + flags.second > 0
+            field: { formula: "fieldId('skills.{skill}', flags.target)" }
+            by: flags.first + flags.second
+          - type: set
+            when: params.points > 0
+            field: { formula: "fieldId('skillCredit.{skill}', flags.target)" }
+            value: >-
+              flags.second > 0 ? flags.left - flags.from - flags.first - 2 : flags.left
+      - id: result
+        kind: outcome
+        result: "'gained'"
+
+  # Background attribute points: +1 to any attribute, or +2 to one physical (or mental)
+  # attribute or +1 to two. None goes past 18.
+  - id: gain-attributes
+    available: false
+    params:
+      kind: { type: enum, values: [any-stat, physical, mental] }
+      random: { type: boolean, default: false }
+    results: [gained]
+    steps:
+      - id: one
+        kind: choice
+        sheet: proposed
+        when: "params.kind == 'any-stat'"
+        random: params.random
+        options:
+          values: [str, dex, con, int, wis, cha]
+          where: "fieldOf('attributes.{attr}.score', value) < 18"
+        recommend: "sortList(options, fieldOf('attributes.{attr}.score', x))[0]"
+        changes:
+          - { type: adjust, field: { formula: "'attributes.' + picked.id + '.score'" }, by: 1 }
+      - id: two
+        kind: allocate
+        sheet: proposed
+        when: "params.kind != 'any-stat'"
+        fields:
+          type: field
+          where: >-
+            params.kind == 'physical'
+              ? item.id in [@attributes.str.score, @attributes.dex.score, @attributes.con.score]
+              : item.id in [@attributes.int.score, @attributes.wis.score, @attributes.cha.score]
+        budget: 2
+        spend: upTo
+        limit: 18 - field.value
+        random: true
+      - id: result
+        kind: outcome
+        result: "'gained'"
+
+  # A Focus: a new one at its first level, or the next level of one held. A new Focus asks its
+  # own choices, then gives its bonus skill.
+  - id: pick-focus
+    available: false
+    params:
+      kind: { type: enum, values: [any, combat, noncombat] }
+      random: { type: boolean, default: false }
+      points: { type: integer, default: 0, min: 0 }
+    results: [picked]
+    steps:
+      - id: focus
+        kind: choice
+        sheet: proposed
+        random: params.random
+        options:
+          content:
+            type: focus
+            where: >-
+              (params.kind == 'any' || params.kind in item.tags)
+                && (!params.random || !('gm-defined' in item.tags))
+                && (item.repeatable || sumCopies(copy.state.level,
+                  copy.type == 'focus' && copy.item == item.id) < item.maxLevel)
+                && (item.requires == 'none'
+                  || (item.requires == 'mage' && class.mage > 0)
+                  || (item.requires == 'non-mage' && class.mage == 0)
+                  || (item.requires == 'expert' && class.expert > 0)
+                  || (item.requires == 'invoker' && tradition.invoker.tier > 0)
+                  || (item.requires == 'low-attribute' && min(attributes.str.score,
+                    attributes.dex.score, attributes.con.score, attributes.int.score,
+                    attributes.wis.score, attributes.cha.score) <= 7))
+        recommend: options[0]
+      - id: held
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              raise: >-
+                countCopies(copy.type == 'focus' && copy.item == steps.focus.picked
+                  && copy.state.level < steps.focus.item.maxLevel) > 0
+      - id: take
+        kind: changes
+        changes:
+          - type: adjustState
+            when: flags.raise
+            copies:
+              { type: focus, where: 'item.id == steps.focus.picked && self.level < item.maxLevel' }
+            limit: 1
+            key: level
+            by: 1
+          - type: addItem
+            when: '!flags.raise'
+            entry: { item: steps.focus.picked, state: { level: 1 } }
+      - id: focusChoices
+        kind: choice
+        when: '!flags.raise'
+        random: params.random
+        options: { pending: { entry: 'steps.take.added[0]' } }
+        recommend: options[0]
+      - id: bonusSkill
+        kind: action
+        when: "!flags.raise && steps.focus.item.bonusSkill != 'none'"
+        use: gain-skill
+        params:
+          skill: >-
+            steps.focus.item.bonusSkill == 'specialist' && has(steps.focusChoices)
+                && size(steps.focusChoices.picked) > 0
+              ? steps.focusChoices.picked[0] : steps.focus.item.bonusSkill
+          random: params.random
+          focus: true
+          points: params.points
+      - id: result
+        kind: outcome
+        result: "'picked'"
+
+  # The arts each tradition still owes, one pick at a time.
+  - id: pick-arts
+    available: false
+    params:
+      random: { type: boolean, default: false }
+    results: [picked]
+    steps:
+      - id: arts
+        kind: choice
+        sheet: proposed
+        random: params.random
+        repeat: { max: arts.owed, min: arts.owed }
+        options:
+          content:
+            type: art
+            where: >-
+              fieldOf('arts.{artTrad}.owed', item.tradition) > 0
+                && (countCopies(copy.item == item.id) == 0 || 'repeatable' in item.tags)
+                && level >= item.minLevel && !('granted' in item.tags)
+                && (!has(item.requiresArt) || countCopies(copy.item == item.requiresArt) > 0)
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { item: picked.id }
+      - id: result
+        kind: outcome
+        result: "'picked'"

package/rules/creation.yaml

@@ -0,0 +1,383 @@
+creation:
+  - { id: guided, action: create-character }
+  - { id: random, action: create-character, params: { random: true }, random: true }
+
+actions:
+  # Both starts, in the book's order: attributes, background and its skills, class, Foci, the
+  # free skill, the tradition's skill, arts and spells, hit points, then equipment. The random
+  # start rolls where the book has a table (attributes, background, Growth and Learning) and
+  # draws evenly among the options where it doesn't.
+  - id: create-character
+    tags: [creation]
+    available: "character.creating && countCopies(copy.type == 'class') == 0"
+    params:
+      random: { type: boolean, default: false }
+    results: [created]
+    steps:
+      # Attributes: 3d6 in order with one raised to 14, or the array placed freely.
+      - id: method
+        kind: choice
+        when: '!params.random'
+        options: [{ id: roll }, { id: array }]
+        recommend: "'roll'"
+      - id: rolled
+        kind: branch
+        cases:
+          - when: "params.random || steps.method.picked == 'roll'"
+            steps:
+              - { id: str, kind: roll, tags: [creation], parts: [{ dice: 3d6 }] }
+              - { id: dex, kind: roll, tags: [creation], parts: [{ dice: 3d6 }] }
+              - { id: con, kind: roll, tags: [creation], parts: [{ dice: 3d6 }] }
+              - { id: int, kind: roll, tags: [creation], parts: [{ dice: 3d6 }] }
+              - { id: wis, kind: roll, tags: [creation], parts: [{ dice: 3d6 }] }
+              - { id: cha, kind: roll, tags: [creation], parts: [{ dice: 3d6 }] }
+              - id: scores
+                kind: changes
+                changes:
+                  - { type: set, field: attributes.str.score, value: steps.str.total }
+                  - { type: set, field: attributes.dex.score, value: steps.dex.total }
+                  - { type: set, field: attributes.con.score, value: steps.con.total }
+                  - { type: set, field: attributes.int.score, value: steps.int.total }
+                  - { type: set, field: attributes.wis.score, value: steps.wis.total }
+                  - { type: set, field: attributes.cha.score, value: steps.cha.total }
+              # One rolled score becomes 14; the lowest is recommended.
+              - id: fourteen
+                kind: choice
+                sheet: proposed
+                options:
+                  values: [str, dex, con, int, wis, cha]
+                  where: "fieldOf('attributes.{attr}.score', value) < 14"
+                recommend: "sortList(options, fieldOf('attributes.{attr}.score', x))[0]"
+                changes:
+                  - {
+                      type: set,
+                      field: { formula: "'attributes.' + picked.id + '.score'" },
+                      value: 14,
+                    }
+          - when: "steps.method.picked == 'array'"
+            steps:
+              - id: array
+                kind: allocate
+                fields: { type: field, where: "'attribute' in item.tags" }
+                values: [14, 12, 11, 10, 9, 7]
+                recommend:
+                  attributes.str.score: 14
+                  attributes.dex.score: 12
+                  attributes.con.score: 11
+                  attributes.int.score: 10
+                  attributes.wis.score: 9
+                  attributes.cha.score: 7
+
+      # Background: the SRD's two, drawn evenly for the random start.
+      - id: background
+        kind: choice
+        random: params.random
+        options: { content: { type: background } }
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { id: background, item: picked.id }
+      - id: tables
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              growth: >-
+                [steps.background.item.growth1, steps.background.item.growth2,
+                  steps.background.item.growth3, steps.background.item.growth4,
+                  steps.background.item.growth5, steps.background.item.growth6]
+              learning: >-
+                [steps.background.item.learning1, steps.background.item.learning2,
+                  steps.background.item.learning3, steps.background.item.learning4,
+                  steps.background.item.learning5, steps.background.item.learning6,
+                  steps.background.item.learning7, steps.background.item.learning8]
+      - id: freeSkill
+        kind: action
+        use: background-entry
+        params: { entry: steps.background.item.freeSkill, random: params.random }
+
+      # The background's skills: two picks from Learning, or three rolls split between Growth and
+      # Learning (the random start rolls).
+      - id: skills
+        kind: choice
+        when: '!params.random'
+        options: [{ id: pick }, { id: roll-tables }]
+        recommend: "'pick'"
+      - id: learn
+        kind: branch
+        cases:
+          - when: "!params.random && steps.skills.picked == 'pick'"
+            steps:
+              - id: learning
+                kind: choice
+                repeat: { max: 2, min: 2 }
+                # Each Learning entry once: an entry the table has twice may be picked twice.
+                options:
+                  values: { formula: flags.learning }
+                  where: "value != 'any' && picks < countList(flags.learning, x == value)"
+                recommend: options[0]
+              - id: learned1
+                kind: action
+                use: background-entry
+                params:
+                  entry: steps.learning.picked[0]
+              - id: learned2
+                kind: action
+                use: background-entry
+                params:
+                  entry: steps.learning.picked[1]
+      - id: rolls
+        kind: branch
+        cases:
+          - when: "params.random || steps.skills.picked == 'roll-tables'"
+            steps:
+              - id: table1
+                kind: choice
+                random: params.random
+                options: [{ id: growth }, { id: learning }]
+                recommend: "'learning'"
+              - id: die1
+                kind: roll
+                tags: [creation]
+                parts: [{ dice: "steps.table1.picked == 'growth' ? 1d6 : 1d8" }]
+              - id: rolled1
+                kind: action
+                use: background-entry
+                params:
+                  entry: >-
+                    steps.table1.picked == 'growth' ? flags.growth[steps.die1.total - 1]
+                      : flags.learning[steps.die1.total - 1]
+                  random: params.random
+              - id: table2
+                kind: choice
+                random: params.random
+                options: [{ id: growth }, { id: learning }]
+                recommend: "'learning'"
+              - id: die2
+                kind: roll
+                tags: [creation]
+                parts: [{ dice: "steps.table2.picked == 'growth' ? 1d6 : 1d8" }]
+              - id: rolled2
+                kind: action
+                use: background-entry
+                params:
+                  entry: >-
+                    steps.table2.picked == 'growth' ? flags.growth[steps.die2.total - 1]
+                      : flags.learning[steps.die2.total - 1]
+                  random: params.random
+              - id: table3
+                kind: choice
+                random: params.random
+                options: [{ id: growth }, { id: learning }]
+                recommend: "'learning'"
+              - id: die3
+                kind: roll
+                tags: [creation]
+                parts: [{ dice: "steps.table3.picked == 'growth' ? 1d6 : 1d8" }]
+              - id: rolled3
+                kind: action
+                use: background-entry
+                params:
+                  entry: >-
+                    steps.table3.picked == 'growth' ? flags.growth[steps.die3.total - 1]
+                      : flags.learning[steps.die3.total - 1]
+                  random: params.random
+
+      # Class, then what it asks: a Mage's tradition, an Adventurer's two partial classes and a
+      # partial Mage's tradition, a Vowed's skill.
+      - id: class
+        kind: choice
+        random: params.random
+        options: { content: { type: class } }
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { id: class, item: picked.id }
+      - id: classChoices
+        kind: choice
+        random: params.random
+        options: { pending: { entry: 'steps.class.added[0]' } }
+        recommend: options[0]
+
+      # Foci: one combat Focus with any Warrior, one non-combat Focus with any Expert, and one of
+      # any kind. Picking a Focus again takes its second level.
+      - id: warriorFocus
+        kind: action
+        sheet: proposed
+        when: class.warrior > 0
+        use: pick-focus
+        params: { kind: "'combat'", random: params.random }
+      - id: expertFocus
+        kind: action
+        sheet: proposed
+        when: class.expert > 0
+        use: pick-focus
+        params: { kind: "'noncombat'", random: params.random }
+      - id: freeFocus
+        kind: action
+        use: pick-focus
+        params: { kind: "'any'", random: params.random }
+
+      # One skill of the player's choice.
+      - id: freePick
+        kind: action
+        use: gain-skill
+        params: { skill: "'any'", random: params.random }
+
+      # Each tradition's bonus skill (`tradition.<key>.skill`): Magic for most Mages, the class's
+      # own skill for the rest, in tradition order.
+      - id: traditionSkills
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              traditionSkills: >-
+                mapList(filterList(keysOf('trad'), fieldOf('tradition.{trad}.tier', x) > 0
+                  && fieldOf('tradition.{trad}.skill', x) != ''), fieldOf('tradition.{trad}.skill', x))
+      - id: traditionSkill
+        kind: group
+        when: size(flags.traditionSkills) > 0
+        repeat: { while: size(steps.traditionSkill) < size(flags.traditionSkills), max: 15 }
+        steps:
+          - id: gain
+            kind: action
+            sheet: proposed
+            use: gain-skill
+            params:
+              skill: flags.traditionSkills[size(steps.traditionSkill)]
+              random: params.random
+
+      # The arts each tradition lets a new mage pick, and the first-level spells they know.
+      - id: arts
+        kind: action
+        use: pick-arts
+        params: { random: params.random }
+      - id: spells
+        kind: choice
+        sheet: proposed
+        when: spells.starting > 0
+        random: params.random
+        repeat: { max: spells.starting, min: spells.starting }
+        options:
+          content:
+            type: spell
+            where: >-
+              item.level == 1 && countCopies(copy.item == item.id) == 0
+                && (item.list == 'high' || (item.list in keysOf('trad')
+                  && (fieldOf('tradition.{trad}.tier', item.list) > 0
+                    || invoker.education == item.list)))
+        recommend: options[0]
+        changes:
+          - type: addItem
+            entry: { item: picked.id, state: { prepared: spells.prepared < spells.preparedMax } }
+
+      # Hit points: 1d6 plus the class's bonus and Constitution, at least 1.
+      - id: hitPoints
+        kind: roll
+        sheet: proposed
+        tags: [creation]
+        parts:
+          - dice: 1d6
+          - field: "'hp.dieBonus'"
+          - field: "'attributes.con.mod'"
+      - id: hp
+        kind: changes
+        changes:
+          - { type: set, field: hp.rolled, value: 'max(1, steps.hitPoints.total)' }
+
+      # Starting gear: 3d6 x 10 silver, spent at list price on a weapon, armor and gear (the
+      # SRD's other choice, a package, is the GM's to provide). A copper price is paid in
+      # silver, the change in copper. The random start draws each purchase among those it can
+      # afford; spellcasters and the Vowed skip armor, which hinders their magic.
+      - { id: silverRoll, kind: roll, tags: [creation], parts: [{ dice: 3d6 }] }
+      - id: purse
+        tags: [creation.purse]
+        kind: changes
+        changes:
+          - { type: adjust, field: coins.silver, by: steps.silverRoll.total * 10 }
+      - id: weapon
+        kind: choice
+        sheet: proposed
+        random: params.random
+        repeat: { max: 1 }
+        options:
+          content:
+            type: weapon
+            where: >-
+              !(item.id in [@weapons.unarmed, @weapons.large-shield-bash,
+                @weapons.small-shield-bash])
+                && (item.costUnit == 'cp' ? ceil(item.cost / 10) : item.cost) <= coins.silver
+        recommend: >-
+          filterList([spells.mode != 'none' || tradition.vowed.tier > 0 ? @weapons.staff
+              : class.warrior > 0 || class.expert > 0 ? @weapons.short-sword
+              : @weapons.light-spear, options[0]], x in options)[0]
+        changes:
+          - { type: addItem, entry: { item: picked.id, equipped: true } }
+          - &pay
+            type: adjust
+            field: coins.silver
+            by: "-(picked.item.costUnit == 'cp' ? ceil(picked.item.cost / 10) : picked.item.cost)"
+          - &change
+            type: adjust
+            field: coins.copper
+            when: "picked.item.costUnit == 'cp'"
+            by: ceil(picked.item.cost / 10) * 10 - picked.item.cost
+      - id: armorBuy
+        kind: choice
+        sheet: proposed
+        options: [{ id: buy-armor }, { id: no-armor }]
+        recommend: "spells.mode != 'none' || tradition.vowed.tier > 0 ? 'no-armor' : 'buy-armor'"
+      # Body armor and a shield, one of each.
+      - id: armor
+        kind: choice
+        sheet: proposed
+        when: "steps.armorBuy.picked == 'buy-armor'"
+        random: params.random
+        repeat: { max: 2 }
+        options:
+          content:
+            type: armor
+            where: >-
+              (item.category == 'shield' ? !armor.shield : armor.wornEnc < 0)
+                && (item.costUnit == 'cp' ? ceil(item.cost / 10) : item.cost) <= coins.silver
+        recommend: >-
+          filterList([@armor.linothorax, @armor.large-shield, @armor.war-shirt, options[0]],
+            x in options)[0]
+        changes:
+          - { type: addItem, entry: { item: picked.id, equipped: true } }
+          - *pay
+          - *change
+      # Up to six pieces of gear, one of each, no more than the character can carry.
+      - id: gear
+        kind: choice
+        sheet: proposed
+        random: params.random
+        repeat: { max: 6 }
+        options:
+          content:
+            type: gear
+            where: >-
+              picks == 0
+                && (item.costUnit == 'cp' ? ceil(item.cost / 10) : item.cost) <= coins.silver
+                && (item.id == @gear.backpack ? enc.readied + item.enc <= enc.readiedLimit + 4
+                  : enc.stowed + item.enc <= enc.stowedLimit + 8)
+        recommend: >-
+          filterList([@gear.backpack, @gear.rations, @gear.waterskin, @gear.tinder-box,
+            @gear.torch, @gear.rope, options[0]], x in options)[0]
+        changes:
+          - type: addItem
+            entry: { item: picked.id, equipped: 'picked.id == @gear.backpack' }
+          - *pay
+          - *change
+
+      - id: finish
+        tags: [creation.finish]
+        kind: changes
+        sheet: proposed
+        changes:
+          - { type: set, field: hp.current, value: hp.max }
+          - { type: finishCreation }
+      - id: result
+        kind: outcome
+        result: "'created'"