@opencharacter/5e-srd-5.1 0.1.0 → 0.3.0

package/rules/creation.yaml

@@ -14,29 +14,36 @@ actions:
     available: character.creating
     steps:
       - id: race
+        tags: [creation.race]
         kind: choice
         options: { content: { type: race } }
         changes:
           - type: addItem
             entry: { id: race, item: picked.id }
       - id: subrace
+        tags: [creation.subrace]
         kind: choice
         options: { content: { type: subrace, where: item.race == steps.race.picked } }
         changes:
-          - { type: choose, path: { entry: race, choice: [subrace] }, option: picked.id }
+          - type: choose
+            path: { entry: { formula: 'steps.race.added[0]' }, choice: [subrace] }
+            option: picked.id
       - id: class
+        tags: [creation.class]
         kind: choice
         options: { content: { type: class } }
         changes:
           - type: addItem
             entry: { id: class, item: picked.id, state: { level: 1, startingClass: true } }
       - id: background
+        tags: [creation.background]
         kind: choice
         options: { content: { type: background } }
         changes:
           - type: addItem
             entry: { id: background, item: picked.id }
       - id: method
+        tags: [creation.method]
         kind: choice
         options: [{ id: roll }, { id: point-buy }, { id: standard-array }]
         recommend: "'standard-array'"
@@ -93,12 +100,12 @@ actions:
       - id: equipment
         kind: action
         use: starting-equipment
-        params: { class: steps.class.picked, background: steps.background.picked }
       - id: hitDie
         kind: changes
         changes:
           - { type: set, field: hp.base, value: maxOf(steps.class.item.hitDie) }
       - id: finish
+        tags: [creation.finish]
         kind: changes
         sheet: proposed
         changes:
@@ -118,6 +125,7 @@ actions:
       - { id: roll5, kind: roll, tags: [creation], parts: [{ dice: 4d6dl1 }] }
       - { id: roll6, kind: roll, tags: [creation], parts: [{ dice: 4d6dl1 }] }
       - id: race
+        tags: [creation.race]
         kind: choice
         options: { content: { type: race } }
         random: true
@@ -125,12 +133,16 @@ actions:
           - type: addItem
             entry: { id: race, item: picked.id }
       - id: subrace
+        tags: [creation.subrace]
         kind: choice
         options: { content: { type: subrace, where: item.race == steps.race.picked } }
         random: true
         changes:
-          - { type: choose, path: { entry: race, choice: [subrace] }, option: picked.id }
+          - type: choose
+            path: { entry: { formula: 'steps.race.added[0]' }, choice: [subrace] }
+            option: picked.id
       - id: class
+        tags: [creation.class]
         kind: choice
         options: { content: { type: class } }
         random: true
@@ -138,14 +150,15 @@ actions:
           - type: addItem
             entry: { id: class, item: picked.id, state: { level: 1, startingClass: true } }
       - id: background
+        tags: [creation.background]
         kind: choice
         options: { content: { type: background } }
         random: true
         changes:
           - type: addItem
             entry: { id: background, item: picked.id }
-      # The class's ability priority: the highest roll goes to its first ability, the next to its
-      # second, and so on. A class this pack doesn't know takes the barbarian's (the first).
+      # The class's ability priority (its abilityPriority): the highest roll goes to its
+      # first ability, the next to its second, and so on.
       - id: priority
         kind: branch
         cases:
@@ -154,34 +167,7 @@ actions:
               sorted: >-
                 sortList([steps.roll1.total, steps.roll2.total, steps.roll3.total,
                   steps.roll4.total, steps.roll5.total, steps.roll6.total], -x)
-              priority: >-
-                [
-                  ['str', 'con', 'dex', 'wis', 'cha', 'int'],
-                  ['cha', 'dex', 'con', 'wis', 'int', 'str'],
-                  ['wis', 'con', 'str', 'dex', 'cha', 'int'],
-                  ['wis', 'con', 'dex', 'int', 'cha', 'str'],
-                  ['str', 'con', 'dex', 'wis', 'cha', 'int'],
-                  ['dex', 'wis', 'con', 'str', 'int', 'cha'],
-                  ['str', 'cha', 'con', 'wis', 'dex', 'int'],
-                  ['dex', 'wis', 'con', 'str', 'int', 'cha'],
-                  ['dex', 'con', 'wis', 'int', 'cha', 'str'],
-                  ['cha', 'con', 'dex', 'wis', 'int', 'str'],
-                  ['cha', 'con', 'dex', 'wis', 'int', 'str'],
-                  ['int', 'con', 'dex', 'wis', 'cha', 'str']
-                ][max(0, indexOf([
-                  @classes.barbarian,
-                  @classes.bard,
-                  @classes.cleric,
-                  @classes.druid,
-                  @classes.fighter,
-                  @classes.monk,
-                  @classes.paladin,
-                  @classes.ranger,
-                  @classes.rogue,
-                  @classes.sorcerer,
-                  @classes.warlock,
-                  @classes.wizard
-                ], steps.class.picked))]
+              priority: steps.class.item.abilityPriority
       - id: scores
         kind: allocate
         fields: { type: field, where: "'ability-base' in item.tags" }
@@ -193,21 +179,25 @@ actions:
           - steps.roll5.total
           - steps.roll6.total
         recommend:
-          'abilities.{ability}.base': flags.sorted[indexOf(flags.priority, '{ability}')]
+          'abilities.{ability}.base': flags.sorted[indexOf(flags.priority, @abilities.{ability}.score)]
       - id: picks
         kind: choice
         options: { pending: {} }
         random: "!(choice.owner == @races.half-elf && choice.id == 'ability-scores')"
-        recommend: flags.priority[minList(options, indexOf(flags.priority, x))]
+        recommend: >-
+          sortList(options, indexOf(flags.priority, [@abilities.str.score, @abilities.dex.score,
+            @abilities.con.score, @abilities.int.score, @abilities.wis.score,
+            @abilities.cha.score][indexOf(['str', 'dex', 'con', 'int', 'wis', 'cha'], x)]))[0]
       - id: equipment
         kind: action
         use: starting-equipment
-        params: { class: steps.class.picked, background: steps.background.picked, random: true }
+        params: { random: true }
       - id: hitDie
         kind: changes
         changes:
           - { type: set, field: hp.base, value: maxOf(steps.class.item.hitDie) }
       - id: finish
+        tags: [creation.finish]
         kind: changes
         sheet: proposed
         changes:

package/rules/display.yaml

@@ -267,7 +267,7 @@ display:
     combat.highJump: { unit: ft, groups: [combat], priority: 2 }
     combat.critRange: { groups: [combat], priority: 3 }
     proficiency.bonus: { groups: [combat, summary], priority: 1, format: signed }
-    level.total: { groups: [summary], priority: 0 }
+    level.total: { groups: [summary], priority: 0, showWhen: '!sheet.monster || level.total > 0' }
     challenge.rating:
       { groups: [summary], priority: 2, format: fraction, showWhen: level.total == 0 }
     proficiencies.weapons: { groups: [proficiencies] }
@@ -319,6 +319,7 @@ display:
         groups: [combat],
         priority: 2,
         input: { min: 0, max: 3, widget: dots },
+        showWhen: '!sheet.monster',
         rolls: [{ action: death-save }],
       }
     deathSaves.failures:
@@ -326,6 +327,7 @@ display:
         groups: [combat],
         priority: 2,
         input: { min: 0, max: 3, widget: dots },
+        showWhen: '!sheet.monster',
         rolls: [{ action: death-save }],
       }
     proficiencies.languages: { groups: [proficiencies], visibility: background }
@@ -336,15 +338,24 @@ display:
     creature.type: { groups: [summary], priority: 2 }
     senses.darkvision: { unit: ft, groups: [summary], priority: 2, showWhen: senses.darkvision > 0 }
     senses.blindsense: { unit: ft, groups: [summary], priority: 2, showWhen: senses.blindsense > 0 }
+    # A monster carries only what it was given, so its carrying shows once it has some.
     carrying.weight:
       {
         unit: lb,
         groups: [summary],
         priority: 2,
         visibility: secondary,
+        showWhen: '!sheet.monster || carrying.weight > 0',
         with: [{ field: carrying.capacity, as: max }],
       }
-    carrying.capacity: { unit: lb, groups: [summary], priority: 2, visibility: secondary }
+    carrying.capacity:
+      {
+        unit: lb,
+        groups: [summary],
+        priority: 2,
+        visibility: secondary,
+        showWhen: '!sheet.monster || carrying.weight > 0',
+      }
     carrying.stowed:
       {
         unit: lb,
@@ -354,6 +365,7 @@ display:
         showWhen: carrying.stowed > 0,
       }
     carrying.stowCapacity: { hidden: true }
+    carrying.stowUnlimited: { hidden: true }
     combat.featherFall: { hidden: true }
     carrying.quivers: { hidden: true }
     carrying.quiveredAmmunition: { hidden: true }
@@ -361,6 +373,7 @@ display:
     carrying.quiveredLong: { hidden: true }
     combat.ignoreArmorStrength: { hidden: true }
     classes.held: { hidden: true }
+    attunement.classUnmet: { hidden: true }
     creature.race: { hidden: true }
     magicItems.ignoreRequirements: { hidden: true }
     combat.missToHit: { hidden: true }
@@ -437,7 +450,6 @@ display:
     hideInPlainSight.active:
       { groups: [class-features], priority: 0, showWhen: hideInPlainSight.active }
     foeSlayer.bonus: { hidden: true }
-    hunter.colossusSlayer: { hidden: true }
     sneakAttack.dice: { groups: [class-features], priority: 1, showWhen: sneakAttack.dice > 0 }
     sorcery.points: { groups: [class-features], priority: 1, showWhen: sorcery.points > 0 }
     eldritchBlast.beams:
@@ -446,21 +458,18 @@ display:
         priority: 1,
         showWhen: '@spells.eldritch-blast in spells.warlock',
       }
-    eldritchBlast.range:
-      {
-        groups: [class-features],
-        priority: 2,
-        showWhen: '@spells.eldritch-blast in spells.warlock',
-      }
     eldritchBlast.push: { groups: [class-features], priority: 2, showWhen: eldritchBlast.push > 0 }
     sorcery.left: { groups: [class-features], priority: 1, showWhen: sorcery.points > 0 }
     sorcery.shortRestRegain: { hidden: true }
     sorcery.metamagic: { hidden: true }
-    draconic.damageType: { hidden: true }
     elementalAffinity.resistant:
       { groups: [class-features], priority: 0, showWhen: elementalAffinity.resistant }
     dragonWings.active:
-      { groups: [class-features], priority: 0, showWhen: draconic.damageType != 'none' }
+      {
+        groups: [class-features],
+        priority: 0,
+        showWhen: "size(picksOf('features.sorcerer.dragon-ancestor', 'dragon')) > 0",
+      }
     warlock.boons: { groups: [class-features], priority: 1, showWhen: size(warlock.boons) > 0 }
     spellcasting.bard.dc:
       { groups: [spellcasting], priority: 0, showWhen: spellcasting.bard.dc > 0 }

package/rules/equipment.yaml

@@ -19,11 +19,13 @@ contentTypes:
               trade-good,
             ],
           required: true,
+          open: true,
         }
       cost: { type: decimal } # gold pieces, per unit
       weight: { type: decimal } # pounds, per unit
       bundle: { type: integer, min: 1 }
-      ammunition: { type: enum, values: [arrow, blowgun-needle, crossbow-bolt, sling-bullet] }
+      ammunition:
+        { type: enum, values: [arrow, blowgun-needle, crossbow-bolt, sling-bullet], open: true }
     state:
       stowed: { type: boolean, default: false }
       quivered: { type: boolean, default: false } # in an Efficient Quiver (below)
@@ -38,6 +40,7 @@ contentTypes:
           type: enum,
           values: [artisans-tools, gaming-set, musical-instrument, kit, other],
           required: true,
+          open: true,
         }
       cost: { type: decimal }
       weight: { type: decimal }
@@ -54,7 +57,7 @@ contentTypes:
   vehicle:
     carried: true
     fields:
-      category: { type: enum, values: [drawn, waterborne], required: true }
+      category: { type: enum, values: [drawn, waterborne], required: true, open: true }
       cost: { type: decimal }
       pulledWeight: { type: decimal }
       speedMph: { type: decimal }
@@ -65,14 +68,10 @@ fields:
     formula: >-
       sumCopies(copy.fields.weight * copy.quantity, has(copy.fields.weight)
         && has(copy.state.stowed) && copy.state.stowed)
-  carrying.stowCapacity:
-    type: decimal
-    formula: >-
-      500 * sumCopies(copy.quantity, copy.item == @magic-items.bag-of-holding)
-        + 120 * sumCopies(copy.quantity, copy.item == @magic-items.handy-haversack)
-  carrying.quivers:
-    type: integer
-    formula: 'sumCopies(copy.quantity, copy.item == @magic-items.efficient-quiver)'
+  # What extradimensional containers and quivers hold: each adds its own (content effects).
+  carrying.stowCapacity: { type: decimal, formula: 0, min: 0 }
+  carrying.stowUnlimited: { type: boolean, formula: false }
+  carrying.quivers: { type: integer, formula: 0, min: 0 }
   carrying.quiveredAmmunition:
     type: integer
     formula: >-
@@ -81,25 +80,23 @@ fields:
   carrying.quiveredJavelins:
     type: integer
     formula: >-
-      sumCopies(copy.quantity, copy.item == @weapons.javelin
+      sumCopies(copy.quantity, 'quiver.javelin' in copy.tags
         && has(copy.state.quivered) && copy.state.quivered)
   carrying.quiveredLong:
     type: integer
     formula: >-
       sumCopies(copy.quantity, copy.type == 'weapon'
-        && copy.item != @weapons.javelin
+        && !('quiver.javelin' in copy.tags)
         && has(copy.state.quivered) && copy.state.quivered)
 
 constraints:
   - id: stowed-without-container
     check: >-
       countCopies(has(copy.state.stowed) && copy.state.stowed) == 0
-        || countCopies(copy.item in [@magic-items.bag-of-holding,
-          @magic-items.handy-haversack, @magic-items.portable-hole]) > 0
+        || carrying.stowUnlimited || carrying.stowCapacity > 0
   - id: stowed-over-capacity
     check: >-
-      carrying.stowed <= carrying.stowCapacity
-        || countCopies(copy.item == @magic-items.portable-hole) > 0
+      carrying.stowUnlimited || carrying.stowed <= carrying.stowCapacity
     data:
       stowed: carrying.stowed
       capacity: carrying.stowCapacity

package/rules/magic-items.yaml

@@ -3,6 +3,8 @@
 templateFields:
   rarity: { type: enum, values: [common, uncommon, rare, very-rare, legendary, artifact] }
   requiresAttunement: { type: boolean, default: false }
+  # Only a character with one of these classes can attune to it.
+  attunementClasses: { type: set, of: class }
   maxCharges: { type: integer, min: 1 }
   recharge: { type: dice }
   attackBonus: { type: integer, default: 0 }
@@ -15,7 +17,12 @@ contentTypes:
     equippable: true
     fields:
       category:
-        { type: enum, values: [potion, ring, rod, scroll, wand, wondrous-item], required: true }
+        {
+          type: enum,
+          values: [potion, ring, rod, scroll, wand, wondrous-item],
+          required: true,
+          open: true,
+        }
       rarity:
         {
           type: enum,
@@ -23,6 +30,7 @@ contentTypes:
           required: true,
         }
       requiresAttunement: { type: boolean }
+      attunementClasses: { type: set, of: class }
       cost: { type: decimal } # gold pieces, where the SRD gives one
       weight: { type: decimal } # pounds, where the SRD gives one
       maxCharges: { type: integer, min: 1 }
@@ -40,6 +48,15 @@ contentTypes:
     state:
       attuned: { type: boolean, default: false }
       stowed: { type: boolean, default: false } # in an extradimensional container (equipment.yaml)
+      usedToday: { type: set, of: string, default: [] }
+    effects:
+      # An attuned item for other classes than the character's (attunementClasses).
+      - target: attunement.classUnmet
+        op: add
+        value: 1
+        when: >-
+          self.attuned && has(item.attunementClasses) && size(item.attunementClasses) > 0
+            && countList(item.attunementClasses, x in classes.held) == 0
 
   storedSpell:
     carried: false
@@ -341,6 +358,7 @@ actions:
       dice: { type: dice, optional: true }
       damageType:
         type: enum
+        open: true
         optional: true
         values:
           [

package/rules/monsters.yaml

@@ -12,6 +12,7 @@ contentTypes:
       creatureType:
         {
           type: enum,
+          open: true,
           values:
             [
               aberration,
@@ -53,6 +54,7 @@ contentTypes:
               sahuagin,
               titan,
             ],
+          open: true,
         }
       shapechanger: { type: boolean }
       swarm: { type: boolean }
@@ -145,7 +147,7 @@ contentTypes:
       cr: { type: decimal, required: true, min: 0, max: 30 }
       xp: { type: integer, min: 0 }
       legendaryActions: { type: integer, min: 1 }
-      ownCopies: { type: set, of: monsterAction, default: [] }
+      ownCopies: { type: list, of: monsterAction, unique: true, default: [] }
       innateOncePerDay: { type: set, of: spell, default: [] }
       innateTwicePerDay: { type: set, of: spell, default: [] }
       innateThricePerDay: { type: set, of: spell, default: [] }
@@ -222,6 +224,7 @@ contentTypes:
       - use: change-form
 
   monsterSpellcasting:
+    grantOnly: true
     carried: false
     fields:
       ability: { type: enum, values: [str, dex, con, int, wis, cha], required: true }
@@ -297,6 +300,7 @@ contentTypes:
               slashing,
               thunder,
             ],
+          open: true,
         }
       versatileDamage: { type: dice }
       damage2: { type: dice }
@@ -319,6 +323,7 @@ contentTypes:
               slashing,
               thunder,
             ],
+          open: true,
         }
       magical: { type: boolean }
       save: { type: enum, values: [str, dex, con, int, wis, cha] }
@@ -343,6 +348,7 @@ contentTypes:
               slashing,
               thunder,
             ],
+          open: true,
         }
       saveEffect: { type: enum, values: [half, none], default: none }
       condition: { type: id, of: condition }
@@ -540,7 +546,7 @@ actions:
         changes:
           - type: choose
             when: has(steps.monster.item.startingForm)
-            path: { entry: monster, choice: [form] }
+            path: { entry: { formula: 'steps.monster.added[0]' }, choice: [form] }
             option: steps.monster.item.startingForm
           - type: addItem
             forEach: steps.monster.item.ownCopies

package/rules/rest.yaml

@@ -86,6 +86,8 @@ actions:
     steps:
       - id: rest
         kind: changes
+        # Content resets its own uses here (`rest.long` changes effects).
+        tags: [rest.long]
         changes:
           - { type: set, field: hp.current, value: hp.max, when: rest.longRestHeals }
           - { type: set, field: hp.temp, value: 0 }
@@ -278,38 +280,6 @@ actions:
             copies: { type: class, where: has(self.wholenessUsed) && self.wholenessUsed }
             key: wholenessUsed
             value: false
-          - type: setState
-            when: countCopies(has(copy.state.hellishRebukeUsed) && copy.state.hellishRebukeUsed) > 0
-            copies: { type: race, where: has(self.hellishRebukeUsed) && self.hellishRebukeUsed }
-            key: hellishRebukeUsed
-            value: false
-          - type: setState
-            when: countCopies(has(copy.state.darknessUsed) && copy.state.darknessUsed) > 0
-            copies: { type: race, where: has(self.darknessUsed) && self.darknessUsed }
-            key: darknessUsed
-            value: false
-          - type: setState
-            when: >-
-              countCopies(copy.item == @magic-items.ring-of-x-ray-vision
-                && copy.state.used) > 0
-            copies:
-              {
-                type: magicItem,
-                where: 'item.id == @magic-items.ring-of-x-ray-vision && self.used',
-              }
-            key: used
-            value: false
-          - type: setState
-            when: >-
-              countCopies(has(copy.state.relentlessEnduranceUsed)
-                && copy.state.relentlessEnduranceUsed) > 0
-            copies:
-              {
-                type: race,
-                where: has(self.relentlessEnduranceUsed) && self.relentlessEnduranceUsed,
-              }
-            key: relentlessEnduranceUsed
-            value: false
           - type: setState
             when: countCopies(has(copy.state.signatureSpell1Used) && copy.state.signatureSpell1Used) > 0
             copies:
@@ -322,47 +292,6 @@ actions:
               { type: class, where: has(self.signatureSpell2Used) && self.signatureSpell2Used }
             key: signatureSpell2Used
             value: false
-          - type: setState
-            when: countCopies(has(copy.state.bewitchingWhispersUsed) && copy.state.bewitchingWhispersUsed) > 0
-            copies:
-              {
-                type: class,
-                where: has(self.bewitchingWhispersUsed) && self.bewitchingWhispersUsed,
-              }
-            key: bewitchingWhispersUsed
-            value: false
-          - type: setState
-            when: countCopies(has(copy.state.dreadfulWordUsed) && copy.state.dreadfulWordUsed) > 0
-            copies: { type: class, where: has(self.dreadfulWordUsed) && self.dreadfulWordUsed }
-            key: dreadfulWordUsed
-            value: false
-          - type: setState
-            when: countCopies(has(copy.state.minionsOfChaosUsed) && copy.state.minionsOfChaosUsed) > 0
-            copies: { type: class, where: has(self.minionsOfChaosUsed) && self.minionsOfChaosUsed }
-            key: minionsOfChaosUsed
-            value: false
-          - type: setState
-            when: countCopies(has(copy.state.mireTheMindUsed) && copy.state.mireTheMindUsed) > 0
-            copies: { type: class, where: has(self.mireTheMindUsed) && self.mireTheMindUsed }
-            key: mireTheMindUsed
-            value: false
-          - type: setState
-            when: countCopies(has(copy.state.sculptorOfFleshUsed) && copy.state.sculptorOfFleshUsed) > 0
-            copies:
-              { type: class, where: has(self.sculptorOfFleshUsed) && self.sculptorOfFleshUsed }
-            key: sculptorOfFleshUsed
-            value: false
-          - type: setState
-            when: countCopies(has(copy.state.signOfIllOmenUsed) && copy.state.signOfIllOmenUsed) > 0
-            copies: { type: class, where: has(self.signOfIllOmenUsed) && self.signOfIllOmenUsed }
-            key: signOfIllOmenUsed
-            value: false
-          - type: setState
-            when: countCopies(has(copy.state.thiefOfFiveFatesUsed) && copy.state.thiefOfFiveFatesUsed) > 0
-            copies:
-              { type: class, where: has(self.thiefOfFiveFatesUsed) && self.thiefOfFiveFatesUsed }
-            key: thiefOfFiveFatesUsed
-            value: false
           - type: setState
             when: countCopies(copy.type == 'monsterAction') > 0
             copies:

package/rules/spellcasting.yaml

@@ -601,6 +601,7 @@ actions:
     steps:
       - id: rest
         kind: changes
+        tags: [rest.short]
         changes:
           - { type: set, field: pactSlots.used, value: 0 }
           - type: removeEffect