@opencharacter/awn-core 0.1.0 → 0.2.0

package/rules/creation.yaml

@@ -290,96 +290,112 @@ actions:
         kind: action
         use: starting-equipment
         params: { random: params.random }
-      # A start may bring more than the survivor can haul. Readied items past the push limit are
-      # stowed, then Stowed ones past it left behind (gear, then weapons, then armor, the heaviest
-      # first), so play starts within the limits.
+      # A start may bring more than the survivor can haul. Readied items past the limit are
+      # stowed; Stowed gear past it is readied where it fits, then left behind (gear, then weapons,
+      # then armor, the heaviest first), so play starts unencumbered.
       - id: stowGear
         kind: choice
         sheet: proposed
-        when: encumbrance.overload > 2
-        repeat: { max: 20 }
+        when: encumbrance.overload > 0
+        repeat: { max: 20, min: 20 }
         options:
           copies:
             type: gear
             where: >-
               self.equipped && has(item.enc) && item.enc > 0
                 && !(has(item.wornFree) && item.wornFree)
-                && encumbrance.readied > encumbrance.readied.max + 4
+                && encumbrance.readied > encumbrance.readied.max
         prefer: item.enc
         changes:
           - { type: equip, entry: picked, equipped: false }
       - id: stowWeapon
         kind: choice
         sheet: proposed
-        when: encumbrance.overload > 2
-        repeat: { max: 20 }
+        when: encumbrance.overload > 0
+        repeat: { max: 20, min: 20 }
         options:
           copies:
             type: weapon
             where: >-
               self.equipped && item.enc > 0
-                && encumbrance.readied > encumbrance.readied.max + 4
+                && encumbrance.readied > encumbrance.readied.max
         prefer: item.enc
         changes:
           - { type: equip, entry: picked, equipped: false }
       - id: stowArmor
         kind: choice
         sheet: proposed
-        when: encumbrance.overload > 2
-        repeat: { max: 20 }
+        when: encumbrance.overload > 0
+        repeat: { max: 20, min: 20 }
         options:
           copies:
             type: armor
             where: >-
               self.equipped && item.enc > 0
-                && encumbrance.readied > encumbrance.readied.max + 4
+                && encumbrance.readied > encumbrance.readied.max
         prefer: item.enc
         changes:
           - { type: equip, entry: picked, equipped: false }
-      - id: dropGear
+      - id: readyGear
         kind: choice
         sheet: proposed
-        when: encumbrance.overload > 2
-        repeat: { max: 20 }
+        when: encumbrance.overload > 0
+        repeat: { max: 20, min: 20 }
         options:
           copies:
             type: gear
             where: >-
               !self.equipped && has(item.enc) && item.enc > 0
-                && encumbrance.stowed > encumbrance.stowed.max + 8
+                && encumbrance.stowed > encumbrance.stowed.max
+                && encumbrance.readied + item.enc * self.quantity <= encumbrance.readied.max
         prefer: item.enc
+        changes:
+          - { type: equip, entry: picked, equipped: true }
+      - id: dropGear
+        kind: choice
+        sheet: proposed
+        when: encumbrance.overload > 0
+        repeat: { max: 20, min: 20 }
+        options:
+          copies:
+            type: gear
+            where: >-
+              !self.equipped && has(item.enc) && item.enc > 0
+                && encumbrance.stowed > encumbrance.stowed.max
+        prefer: "item.enc * ('bundleable' in item.tags ? floor((self.quantity + 2) / 3) : self.quantity)"
         changes:
           - { type: removeItem, entry: picked }
       - id: dropWeapon
         kind: choice
         sheet: proposed
-        when: encumbrance.overload > 2
-        repeat: { max: 20 }
+        when: encumbrance.overload > 0
+        repeat: { max: 20, min: 20 }
         options:
           copies:
             type: weapon
             where: >-
               !self.equipped && item.enc > 0
-                && encumbrance.stowed > encumbrance.stowed.max + 8
+                && encumbrance.stowed > encumbrance.stowed.max
         prefer: item.enc
         changes:
           - { type: removeItem, entry: picked }
       - id: dropArmor
         kind: choice
         sheet: proposed
-        when: encumbrance.overload > 2
-        repeat: { max: 20 }
+        when: encumbrance.overload > 0
+        repeat: { max: 20, min: 20 }
         options:
           copies:
             type: armor
             where: >-
               !self.equipped && item.enc > 0
-                && encumbrance.stowed > encumbrance.stowed.max + 8
+                && encumbrance.stowed > encumbrance.stowed.max
         prefer: item.enc
         changes:
           - { type: removeItem, entry: picked }
 
       - id: finish
+        tags: [creation.finish]
         kind: changes
         sheet: proposed
         changes:
@@ -391,11 +407,41 @@ actions:
   # One entry of a background's tables: a skill (`any-combat`, `any-skill` or a skill key), or
   # an attribute bonus, which the highest attribute that can take it all is recommended.
   - id: gain-benefit
+    available: character.creating
     params:
-      entry: { type: string }
+      entry:
+        type: enum
+        open: true
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            any-combat,
+            any-skill,
+            any-stat-1,
+            physical2,
+            mental2,
+          ]
       prefer: { type: set, of: string, default: [] }
       random: { type: boolean, default: false }
-    results: [gained]
+    results: [gained, none]
     steps:
       - id: skill
         kind: action
@@ -446,4 +492,4 @@ actions:
             by: 1
       - id: result
         kind: outcome
-        result: "'gained'"
+        result: "has(steps.skill) && steps.skill.result == 'none' ? 'none' : 'gained'"

package/rules/features.yaml

@@ -4,6 +4,8 @@ contentTypes:
   edge:
     fields:
       bonusSkill: { type: set, of: string, default: [] }
+      # It has a `gain-part` action, run when the edge is taken.
+      gainPart: { type: boolean, default: false }
     effects:
       - { target: edges.held, op: grant, value: { formula: item.id } }
 
@@ -18,6 +20,8 @@ contentTypes:
       specialty: { type: boolean, default: false }
       bonusSkill: { type: set, of: string, default: [] }
       bonusSkill2: { type: set, of: string, default: [] }
+      # It has a `gain-part` action, run when the focus is taken.
+      gainPart: { type: boolean, default: false }
     state:
       level: { type: integer, default: 1, min: 1, max: item.maxLevel }
     effects:
@@ -35,7 +39,9 @@ fields:
 
   # Two edges at 1st level and one at 5th; Forged By Fire takes the place of the first two and
   # gives one at each of 2nd, 3rd and 4th instead.
-  edges.forgedByFire: { type: boolean, formula: '@edges.forged-by-fire in edges.held' }
+  edges.forgedByFire:
+    type: boolean
+    formula: "countCopies(copy.type == 'edge' && 'first-edge' in copy.tags) > 0"
   edges.allowed:
     type: integer
     formula: >-
@@ -61,9 +67,8 @@ constraints:
     check: '!character.creating || !edges.underdog || attributes.baseTotal <= -1'
   # Each edge once, but Focused; each focus once, but Specialist.
   - id: edge-once
-    check: >-
-      countCopies(copy.type == 'edge' && copy.item != @edges.focused) == size(edges.held)
-        - (@edges.focused in edges.held ? 1 : 0)
+    copies: { type: edge, where: "!('repeatable' in item.tags)" }
+    check: countCopies(copy.item == item.id) == 1
   - id: focus-once
     copies: { type: focus, where: '!item.multiple' }
     check: countCopies(copy.item == item.id) == 1

package/rules/gear.yaml

@@ -20,6 +20,8 @@ contentTypes:
       techLevel: { type: integer, min: 0, max: 5 }
       traumaDie: { type: dice }
       traumaRating: { type: integer, min: 1 }
+      # The ammunition a primitive missile weapon starts with in a wasteland warrior's kit.
+      kitAmmo: { type: id, of: gear }
     state:
       shots: { type: integer, min: 0, default: 'has(item.magazine) ? item.magazine : 0' }
     computed:
@@ -101,6 +103,19 @@ contentTypes:
       # Drugs and stims: the Heal level applying it needs.
       healSkill: { type: integer, min: 0 }
 
+  # A pick on the prepared survivors' list: the item (`gear`, a weapon, armor or gear ID; another
+  # pack's qualified), how many, readied or not, and what comes with it (a firearm's magazines).
+  prepared:
+    grantOnly: true
+    carried: false
+    copies: { max: 0 }
+    fields:
+      gear: { type: string, required: true }
+      quantity: { type: integer, default: 1, min: 1 }
+      equipped: { type: boolean, default: false }
+      extra: { type: string }
+      extraQuantity: { type: integer, default: 1, min: 1 }
+
 # Everyone has fists.
 standardCopies:
   - { type: weapon, where: 'item.id == @weapons.unarmed' }
@@ -154,7 +169,11 @@ situational:
 
 resultBands:
   attack:
-    - { id: hit, when: 'roll.kept[0] == 20 || (roll.kept[0] != 1 && roll.total >= flags.ac)' }
+    - {
+        id: hit,
+        when: 'roll.kept[0] == 20 || (roll.kept[0] != 1 && roll.total >= flags.ac)',
+        success: true,
+      }
     - { id: miss, when: true }
 
 actions:

package/rules/layout.yaml

@@ -118,6 +118,8 @@ display:
     foci.bonus: { hidden: true }
     encumbrance.armorFactor: { hidden: true }
     mutations.mutant: { hidden: true }
+    mutations.barred: { hidden: true }
+    mutations.points.edges: { hidden: true }
     mutations.noVision: { hidden: true }
     mutations.noHearing: { hidden: true }
     mutations.sensitiveSkin: { hidden: true }

package/rules/mutations.yaml

@@ -1,15 +1,16 @@
 contentTypes:
+  # The positive mutations' categories: the book's six, in its order on the d6 table.
+  mutationCategory:
+    grantOnly: true
+    carried: false
+    copies: { max: 0 }
+
   # Positive mutations: their category and their d10 roll within it (the d6 picks the category).
   # `origin` is how it was bought: one point rolled, three for a pair rolled in one category,
   # three chosen, or free (a negative mutation's compensation, the Unstable Mutant focus).
   mutation:
     fields:
-      category:
-        {
-          type: enum,
-          values: [structure, sense, hybrid, cognition, pseudo-psychic, exotic],
-          required: true,
-        }
+      category: { type: id, of: mutationCategory, required: true }
       roll: { type: integer, required: true, min: 1, max: 10 }
       bonusSkill: { type: set, of: string, default: [] }
     state:
@@ -23,14 +24,20 @@ contentTypes:
       light: { type: boolean, default: false }
 
 fields:
-  mutations.mutant: { type: boolean, formula: '@edges.mutant in edges.held' }
+  mutations.mutant:
+    type: boolean
+    formula: "countCopies(copy.type == 'edge' && 'makes-mutant' in copy.tags) > 0"
+  # An edge that bars mutation is held (Hardened Genetics).
+  mutations.barred:
+    type: boolean
+    formula: "countCopies(copy.type == 'edge' && 'not-mutant' in copy.tags) > 0"
+  # Mutation points edges give: 2 for Mutant, 2 for Mutation Acceleration.
+  mutations.points.edges: { type: integer, formula: 0 }
   mutations.negatives: { type: integer, formula: "countCopies(copy.type == 'negative')" }
-  # Mutation points: 2 for Mutant, 2 for Mutation Acceleration, 2 per negative mutation.
+  # Mutation points: the edges', and 2 per negative mutation.
   mutations.points.total:
     type: integer
-    formula: >-
-      (mutations.mutant ? 2 : 0) + (@edges.mutation-acceleration in edges.held ? 2 : 0)
-        + 2 * mutations.negatives
+    formula: mutations.points.edges + 2 * mutations.negatives
   # A stigma that normal clothing hides costs a point.
   mutations.stigmaConcealed: { type: boolean, input: true, default: false }
   mutations.points.spent:
@@ -50,17 +57,31 @@ fields:
   # The stigma, from the suggestion tables: a body part (a second one when the first roll says
   # so), the nature of the change, and a detail.
   stigma.part:
-    { type: enum, input: true, default: none, values: [none, head, arms, legs, torso, senses] }
+    {
+      type: enum,
+      input: true,
+      open: true,
+      default: none,
+      values: [none, head, arms, legs, torso, senses],
+    }
   stigma.part2:
-    { type: enum, input: true, default: none, values: [none, head, arms, legs, torso, senses] }
+    {
+      type: enum,
+      input: true,
+      open: true,
+      default: none,
+      values: [none, head, arms, legs, torso, senses],
+    }
   stigma.nature:
     type: enum
     input: true
+    open: true
     default: none
     values: [none, appearance, animal, size, plant, amorphous, mineral]
   stigma.detail:
     type: enum
     input: true
+    open: true
     default: none
     values:
       [
@@ -137,6 +158,7 @@ actions:
   # The random start rolls a d4 for 0-3 negative mutations and spends every point on single
   # random rolls; the guided one recommends no negative mutation and the same rolls.
   - id: mutate
+    available: character.creating
     tags: [creation]
     params:
       random: { type: boolean, default: false }
@@ -275,6 +297,7 @@ actions:
   # The stigma suggestions: a d6 body part (on a 6, two parts), a d6 nature, and a d12 detail
   # from the column that matches the nature (texture for size, amorphous and mineral changes).
   - id: roll-stigma
+    available: character.creating
     tags: [creation]
     results: [rolled]
     steps:
@@ -333,6 +356,7 @@ actions:
   # (or a second lightly touched result) is rolled again, twice; after that a uniform draw among
   # the ones left stands in for rolling until something new comes up.
   - id: roll-negative-mutation
+    available: character.creating
     tags: [creation]
     params:
       random: { type: boolean, default: false }
@@ -490,7 +514,7 @@ actions:
           content:
             type: mutation
             where: >-
-              item.category == 'sense' && !('vision' in item.tags)
+              item.category == @mutation-categories.sense && !('vision' in item.tags)
                 && countCopies(copy.item == item.id) == 0
         random: params.random
         recommend: options[0]
@@ -504,12 +528,14 @@ actions:
   # Spending mutation points: one to roll a positive mutation, three to roll two in a category,
   # three to choose one.
   - id: buy-mutation
+    available: character.creating
     tags: [creation]
     params:
       random: { type: boolean, default: false }
     results: [bought]
     steps:
       - id: how
+        tags: [creation.mutation]
         kind: choice
         sheet: proposed
         options:
@@ -525,15 +551,9 @@ actions:
       - id: category
         kind: choice
         when: "steps.how.picked == 'category'"
-        options:
-          - { id: structure }
-          - { id: sense }
-          - { id: hybrid }
-          - { id: cognition }
-          - { id: pseudo-psychic }
-          - { id: exotic }
+        options: { content: { type: mutationCategory } }
         random: params.random
-        recommend: options[0]
+        recommend: 'filterList([@mutation-categories.structure, options[0]], x in options)[0]'
       - id: pair1
         kind: action
         when: "steps.how.picked == 'category'"
@@ -574,10 +594,11 @@ actions:
   # it. A result the character can't take (held already, or barred by a negative mutation) is
   # rolled again; a uniform draw among those it can take stands in for rolling until one fits.
   - id: roll-mutation
+    available: character.creating
     tags: [creation]
     params:
       origin: { type: enum, values: [random, category, chosen, free, unstable], default: random }
-      category: { type: string, optional: true }
+      category: { type: id, of: mutationCategory, optional: true }
       random: { type: boolean, default: false }
     results: [rolled]
     steps:
@@ -595,8 +616,10 @@ actions:
             flags:
               category: >-
                 has(params.category) ? params.category
-                  : ['structure', 'sense', 'hybrid', 'cognition', 'pseudo-psychic',
-                    'exotic'][steps.categoryRoll.total - 1]
+                  : [@mutation-categories.structure, @mutation-categories.sense,
+                    @mutation-categories.hybrid, @mutation-categories.cognition,
+                    @mutation-categories.pseudo-psychic,
+                    @mutation-categories.exotic][steps.categoryRoll.total - 1]
       - { id: roll, kind: roll, tags: [creation], parts: [{ dice: 1d10 }] }
       - id: exact
         kind: choice
@@ -645,6 +668,7 @@ actions:
   # Levels past a skill's cap (a skill a negative mutation forbids, or Slow Development's lower
   # maximum) go to other skills, a pick per level: the skill drops to its cap.
   - id: reassign-barred-skills
+    available: character.creating
     tags: [creation]
     params:
       random: { type: boolean, default: false }
@@ -669,7 +693,7 @@ actions:
         changes:
           - type: set
             forEach: flags.barred
-            field: { formula: "'skills.' + x + '.level'" }
+            field: { formula: "fieldId('skills.{skill}.level', x)" }
             value: "max(-1, fieldOf('skills.{skill}.cap', x))"
       - {
           id: relearn1,

package/rules/skills.yaml

@@ -59,11 +59,12 @@ actions:
   # skill when none of the offered ones can take it). `skills` lists the skill keys offered (all
   # when empty); `prefer` the ones to recommend, in order.
   - id: gain-skill
+    listed: false
     params:
       skills: { type: set, of: string, default: [] }
       prefer: { type: set, of: string, default: [] }
       random: { type: boolean, default: false }
-    results: [gained]
+    results: [gained, none]
     steps:
       - id: open
         kind: branch
@@ -91,16 +92,19 @@ actions:
             flags:
               suggest: >-
                 size(filterList(params.prefer, x in flags.offered)) > 0
-                  ? filterList(params.prefer, x in flags.offered)[0] : flags.offered[0]
+                  ? filterList(params.prefer, x in flags.offered)[0]
+                  : size(flags.offered) > 0 ? flags.offered[0] : ''
+      # Every skill at its cap: nothing to gain.
       - id: skill
         kind: choice
+        when: size(flags.offered) > 0
         options: { values: { formula: flags.offered } }
         random: params.random
         recommend: flags.suggest
         changes:
           - type: adjust
-            field: { formula: "'skills.' + picked.value + '.level'" }
+            field: { formula: "fieldId('skills.{skill}.level', picked.value)" }
             by: 1
       - id: result
         kind: outcome
-        result: "'gained'"
+        result: "has(steps.skill) ? 'gained' : 'none'"

package/rules/starting-equipment.yaml

@@ -4,121 +4,43 @@ actions:
   # wasteland warriors get a kit, then one pick or three rolls on a d20 table: the near-future
   # one or the wasteland one. The book's default setting is a wasteland, so that is recommended.
   - id: starting-equipment
+    available: character.creating
     tags: [creation]
     params:
       random: { type: boolean, default: false }
     results: [equipped]
     steps:
       - id: kit
+        tags: [creation.kit]
         kind: choice
         options: [{ id: innocents }, { id: prepared }, { id: near-future }, { id: wasteland }]
         recommend: "'wasteland'"
+      # Four different picks from the list (`prepared` content, an add-on pack's too).
       - id: prepared
         kind: choice
         when: "steps.kit.picked == 'prepared'"
         repeat: { max: 4, min: 4 }
         random: params.random
         recommend: >-
-          size(filterList(['knife', 'first-aid-kit', 'preserved-food', 'backpack'], x in options)) > 0
-            ? filterList(['knife', 'first-aid-kit', 'preserved-food', 'backpack'], x in options)[0]
+          size(filterList([@prepared.knife, @prepared.first-aid-kit, @prepared.preserved-food,
+            @prepared.backpack], x in options)) > 0
+            ? filterList([@prepared.knife, @prepared.first-aid-kit, @prepared.preserved-food,
+              @prepared.backpack], x in options)[0]
             : options[0]
-        options:
-          - id: light-pistol
-            when: picks == 0
-            changes:
-              - { type: addItem, entry: { item: "'weapons.light-pistol'", equipped: true } }
-              - { type: addItem, entry: { item: "'gear.magazine'", quantity: 2 } }
-          - id: heavy-pistol
-            when: picks == 0
-            changes:
-              - { type: addItem, entry: { item: "'weapons.heavy-pistol'", equipped: true } }
-              - { type: addItem, entry: { item: "'gear.magazine'", quantity: 2 } }
-          - id: rifle
-            when: picks == 0
-            changes:
-              - { type: addItem, entry: { item: "'weapons.rifle'", equipped: true } }
-              - { type: addItem, entry: { item: "'gear.magazine'", quantity: 2 } }
-          - id: shotgun
-            when: picks == 0
-            changes:
-              - { type: addItem, entry: { item: "'weapons.shotgun'", equipped: true } }
-              - { type: addItem, entry: { item: "'gear.ammo'", quantity: 2 } }
-          # A criminal's non-military firearm: the semi-auto shotgun stands for any of them.
-          - id: criminal-firearm
-            when: picks == 0
-            changes:
-              - { type: addItem, entry: { item: "'weapons.semi-auto-shotgun'", equipped: true } }
-              - { type: addItem, entry: { item: "'gear.magazine'", quantity: 2 } }
-          - id: knife
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'weapons.knife'", equipped: true } }]
-          - id: smartphone
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.smartphone'" } }]
-          - id: preserved-food
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.preserved-food'" } }]
-          - id: camping-kit
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.camping-kit'" } }]
-          - id: first-aid-kit
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.first-aid-kit'" } }]
-          - id: tent
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.tent'" } }]
-          - id: toolkit
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.toolkit'" } }]
-          - id: flashlight
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.flashlight'" } }]
-          - id: cold-weather-clothes
-            when: picks == 0
-            changes:
-              [{ type: addItem, entry: { item: "'gear.clothes-cold-weather'", equipped: true } }]
-          - id: sleeping-bag
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.sleeping-bag'" } }]
-          - id: cash
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.cash'" } }]
-          - id: laptop
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.laptop'" } }]
-          - id: walkie-talkies
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.walkie-talkie'", quantity: 2 } }]
-          - id: solar-charger
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.solar-charger'" } }]
-          - id: radio
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.radio'" } }]
-          - id: lockpick-kit
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.lockpick-kit'" } }]
-          - id: lighters
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.lighters'" } }]
-          - id: purification-tablets
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.purification-tablets'" } }]
-          - id: profession-item
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.profession-item'" } }]
-          - id: backpack
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.backpack'", equipped: true } }]
-          - id: binoculars
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.binoculars'" } }]
-          - id: water-purifier
-            when: picks == 0
-            changes: [{ type: addItem, entry: { item: "'gear.water-purifier'" } }]
+        options: { content: { type: prepared, where: picks == 0 } }
+        changes:
+          - type: addItem
+            entry:
+              item: picked.item.gear
+              quantity: picked.item.quantity
+              equipped: picked.item.equipped
+          - type: addItem
+            when: has(picked.item.extra)
+            entry: { item: picked.item.extra, quantity: picked.item.extraQuantity }
 
-      # The warrior's kit: a primitive melee weapon or a primitive bow with 20 arrows, a knife,
-      # backpack, sleeping bag, tinderbox, three torches, clothes and 1d4 days of food.
+      # The warrior's kit: a primitive melee weapon or a primitive bow with 20 arrows (a primitive
+      # missile weapon with its `kitAmmo`), a knife, backpack, sleeping bag, tinderbox, three
+      # torches, clothes and 1d4 days of food.
       - id: weapon
         kind: choice
         when: "steps.kit.picked == 'near-future' || steps.kit.picked == 'wasteland'"
@@ -127,14 +49,14 @@ actions:
             type: weapon
             where: >-
               has(item.techLevel) && item.techLevel <= 1 && !('grenade' in item.tags)
-                && ('stab' in item.skills || item.id == @weapons.primitive-bow)
+                && ('stab' in item.skills || has(item.kitAmmo))
         random: params.random
         recommend: options[0]
         changes:
           - { type: addItem, entry: { item: picked.id, equipped: true } }
           - type: addItem
-            when: picked.id == @weapons.primitive-bow
-            entry: { item: "'gear.arrows'" }
+            when: has(picked.item.kitAmmo)
+            entry: { item: picked.item.kitAmmo }
       - id: food
         kind: roll
         tags: [creation]
@@ -207,6 +129,7 @@ actions:
   # One entry of a warrior's d20 table. The wasteland table's three high-tech items stand for
   # rolls on the GM's loot tables, which this pack doesn't model.
   - id: kit-entry
+    available: character.creating
     tags: [creation]
     params:
       table: { type: string }