@opencharacter/wwn-srd 0.0.0-stage → 0.1.0

package/rules/creation.yaml

@@ -0,0 +1,448 @@
+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: Magic for most Mages, the class's own skill for the rest.
+      - id: highmageSkill
+        kind: action
+        sheet: proposed
+        when: tradition.highmage.tier > 0
+        use: gain-skill
+        params: { skill: "'magic'", random: params.random }
+      - id: elementalistSkill
+        kind: action
+        sheet: proposed
+        when: tradition.elementalist.tier > 0
+        use: gain-skill
+        params: { skill: "'magic'", random: params.random }
+      - id: necromancerSkill
+        kind: action
+        sheet: proposed
+        when: tradition.necromancer.tier > 0
+        use: gain-skill
+        params: { skill: "'magic'", random: params.random }
+      - id: invokerSkill
+        kind: action
+        sheet: proposed
+        when: tradition.invoker.tier > 0
+        use: gain-skill
+        params: { skill: "'magic'", random: params.random }
+      - id: healerSkill
+        kind: action
+        sheet: proposed
+        when: tradition.healer.tier > 0
+        use: gain-skill
+        params: { skill: "'heal'", random: params.random }
+      - id: vowedSkill
+        kind: action
+        sheet: proposed
+        when: tradition.vowed.tier > 0 && vowed.skill != ''
+        use: gain-skill
+        params: { skill: vowed.skill, random: params.random }
+      - id: accursedSkill
+        kind: action
+        sheet: proposed
+        when: tradition.accursed.tier > 0
+        use: gain-skill
+        params: { skill: "'magic'", random: params.random }
+      - id: bardSkill
+        kind: action
+        sheet: proposed
+        when: tradition.bard.tier > 0
+        use: gain-skill
+        params: { skill: "'perform'", random: params.random }
+      - id: beastmasterSkill
+        kind: action
+        sheet: proposed
+        when: tradition.beastmaster.tier > 0
+        use: gain-skill
+        params: { skill: "'survive'", random: params.random }
+      - id: bloodpriestSkill
+        kind: action
+        sheet: proposed
+        when: tradition.bloodpriest.tier > 0
+        use: gain-skill
+        params: { skill: "'pray'", random: params.random }
+      - id: duelistSkill
+        kind: action
+        sheet: proposed
+        when: tradition.duelist.tier > 0
+        use: gain-skill
+        params: { skill: "'stab'", random: params.random }
+      - id: mageslayerSkill
+        kind: action
+        sheet: proposed
+        when: tradition.mageslayer.tier > 0
+        use: gain-skill
+        params: { skill: "'magic'", random: params.random }
+      - id: skinshifterSkill
+        kind: action
+        sheet: proposed
+        when: tradition.skinshifter.tier > 0
+        use: gain-skill
+        params: { skill: "'survive'", random: params.random }
+      - id: thoughtnobleSkill
+        kind: action
+        sheet: proposed
+        when: tradition.thoughtnoble.tier > 0
+        use: gain-skill
+        params: { skill: "'notice'", random: params.random }
+      - id: wiseSkill
+        kind: action
+        sheet: proposed
+        when: tradition.wise.tier > 0 && wise.skill != ''
+        use: gain-skill
+        params: { skill: wise.skill, 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 == 'elementalist'
+                  && (tradition.elementalist.tier > 0 || invoker.education == 'elementalist'))
+                  || (item.list == 'necromancer' && (tradition.necromancer.tier > 0
+                    || invoker.education == 'necromancer')))
+        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
+        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.
+      - 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
+        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
+        kind: changes
+        sheet: proposed
+        changes:
+          - { type: set, field: hp.current, value: hp.max }
+          - { type: finishCreation }
+      - id: result
+        kind: outcome
+        result: "'created'"