@opencharacter/orc-2e 0.1.0 → 0.3.0

package/rules/skills.yaml

@@ -4,6 +4,34 @@
 # highest rank less the training, 0 while untrained; an untrained skill's increases input carries
 # the computed tag `untrained`, so level-up leaves it out.
 fields:
+  # What a choice of any skill offers (class trainings, Skill Training) and of any Lore (Gnome
+  # Obsession): an add-on's Lore grants its tag into both.
+  skills.offered:
+    type: set
+    of: tag
+    members: { under: [skill], except: [skill.lore] }
+    formula: >-
+      ['skill.acrobatics', 'skill.arcana', 'skill.athletics', 'skill.crafting',
+        'skill.deception', 'skill.diplomacy', 'skill.intimidation', 'skill.medicine',
+        'skill.nature', 'skill.occultism', 'skill.performance', 'skill.religion',
+        'skill.society', 'skill.stealth', 'skill.survival', 'skill.thievery',
+        'skill.lore.academia', 'skill.lore.circus', 'skill.lore.farming', 'skill.lore.legal',
+        'skill.lore.scribing', 'skill.lore.underworld', 'skill.lore.warfare']
+  skills.lores:
+    type: set
+    of: tag
+    members: { under: [skill.lore] }
+    formula: >-
+      ['skill.lore.academia', 'skill.lore.circus', 'skill.lore.farming', 'skill.lore.legal',
+        'skill.lore.scribing', 'skill.lore.underworld', 'skill.lore.warfare',
+        'skill.lore.alcohol', 'skill.lore.art', 'skill.lore.cooking', 'skill.lore.engineering',
+        'skill.lore.fortune-telling', 'skill.lore.games', 'skill.lore.genealogy',
+        'skill.lore.gladiatorial', 'skill.lore.guild', 'skill.lore.heraldry',
+        'skill.lore.herbalism', 'skill.lore.labor', 'skill.lore.mercantile', 'skill.lore.mining',
+        'skill.lore.sailing', 'skill.lore.tanning', 'skill.lore.theater', 'skill.lore.cave',
+        'skill.lore.desert', 'skill.lore.forest', 'skill.lore.mountain', 'skill.lore.plains',
+        'skill.lore.swamp', 'skill.lore.dwarf', 'skill.lore.elf', 'skill.lore.goblin',
+        'skill.lore.halfling', 'skill.lore.leshy', 'skill.lore.orc']
   # A skill trained twice counts once in the set, so the difference is trainings to spend elsewhere.
   skills.trained: { type: set, of: tag, members: { under: [skill], except: [skill.lore] } }
   skills.trainings: { type: integer, formula: 0 }
@@ -949,32 +977,7 @@ choices:
     unique: skill-training
     pick: max(0, skills.trainings - countList(skills.trained, !(x in skills.chosen)))
     from:
-      values:
-        [
-          skill.acrobatics,
-          skill.arcana,
-          skill.athletics,
-          skill.crafting,
-          skill.deception,
-          skill.diplomacy,
-          skill.intimidation,
-          skill.medicine,
-          skill.nature,
-          skill.occultism,
-          skill.performance,
-          skill.religion,
-          skill.society,
-          skill.stealth,
-          skill.survival,
-          skill.thievery,
-          skill.lore.academia,
-          skill.lore.circus,
-          skill.lore.farming,
-          skill.lore.legal,
-          skill.lore.scribing,
-          skill.lore.underworld,
-          skill.lore.warfare,
-        ]
+      values: { formula: skills.offered }
       where: '!(value in skills.trained) && !(value in skills.chosen) || value in choice.picks'
     effects:
       - { target: skills.chosen, op: grant, value: { formula: pick.value } }
@@ -1125,92 +1128,206 @@ display:
     skills.acrobatics.rank: { format: { bands: rank } }
     skills.acrobatics.granted: { hidden: true }
     skills.acrobatics.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.acrobatics.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.acrobatics.mod } }],
+        with: [{ field: skills.acrobatics.rank, as: detail }],
+      }
     skills.arcana.rank: { format: { bands: rank } }
     skills.arcana.granted: { hidden: true }
     skills.arcana.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.arcana.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.arcana.mod } }],
+        with: [{ field: skills.arcana.rank, as: detail }],
+      }
     skills.athletics.rank: { format: { bands: rank } }
     skills.athletics.granted: { hidden: true }
     skills.athletics.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.athletics.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.athletics.mod } }],
+        with: [{ field: skills.athletics.rank, as: detail }],
+      }
     skills.crafting.rank: { format: { bands: rank } }
     skills.crafting.granted: { hidden: true }
     skills.crafting.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.crafting.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.crafting.mod } }],
+        with: [{ field: skills.crafting.rank, as: detail }],
+      }
     skills.deception.rank: { format: { bands: rank } }
     skills.deception.granted: { hidden: true }
     skills.deception.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.deception.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.deception.mod } }],
+        with: [{ field: skills.deception.rank, as: detail }],
+      }
     skills.diplomacy.rank: { format: { bands: rank } }
     skills.diplomacy.granted: { hidden: true }
     skills.diplomacy.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.diplomacy.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.diplomacy.mod } }],
+        with: [{ field: skills.diplomacy.rank, as: detail }],
+      }
     skills.intimidation.rank: { format: { bands: rank } }
     skills.intimidation.granted: { hidden: true }
     skills.intimidation.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.intimidation.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.intimidation.mod } }],
+        with: [{ field: skills.intimidation.rank, as: detail }],
+      }
     skills.medicine.rank: { format: { bands: rank } }
     skills.medicine.granted: { hidden: true }
     skills.medicine.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.medicine.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.medicine.mod } }],
+        with: [{ field: skills.medicine.rank, as: detail }],
+      }
     skills.nature.rank: { format: { bands: rank } }
     skills.nature.granted: { hidden: true }
     skills.nature.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.nature.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.nature.mod } }],
+        with: [{ field: skills.nature.rank, as: detail }],
+      }
     skills.occultism.rank: { format: { bands: rank } }
     skills.occultism.granted: { hidden: true }
     skills.occultism.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.occultism.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.occultism.mod } }],
+        with: [{ field: skills.occultism.rank, as: detail }],
+      }
     skills.performance.rank: { format: { bands: rank } }
     skills.performance.granted: { hidden: true }
     skills.performance.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.performance.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.performance.mod } }],
+        with: [{ field: skills.performance.rank, as: detail }],
+      }
     skills.religion.rank: { format: { bands: rank } }
     skills.religion.granted: { hidden: true }
     skills.religion.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.religion.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.religion.mod } }],
+        with: [{ field: skills.religion.rank, as: detail }],
+      }
     skills.society.rank: { format: { bands: rank } }
     skills.society.granted: { hidden: true }
     skills.society.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.society.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.society.mod } }],
+        with: [{ field: skills.society.rank, as: detail }],
+      }
     skills.stealth.rank: { format: { bands: rank } }
     skills.stealth.granted: { hidden: true }
     skills.stealth.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.stealth.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.stealth.mod } }],
+        with: [{ field: skills.stealth.rank, as: detail }],
+      }
     skills.survival.rank: { format: { bands: rank } }
     skills.survival.granted: { hidden: true }
     skills.survival.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.survival.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.survival.mod } }],
+        with: [{ field: skills.survival.rank, as: detail }],
+      }
     skills.thievery.rank: { format: { bands: rank } }
     skills.thievery.granted: { hidden: true }
     skills.thievery.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.thievery.mod } }] }
-    skills.lore.academia.rank: { format: { bands: rank } }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.thievery.mod } }],
+        with: [{ field: skills.thievery.rank, as: detail }],
+      }
+    skills.lore.academia.rank: { format: { bands: rank }, showWhen: skills.lore.academia.rank > 0 }
     skills.lore.academia.granted: { hidden: true }
     skills.lore.academia.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.lore.academia.mod } }] }
-    skills.lore.circus.rank: { format: { bands: rank } }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.lore.academia.mod } }],
+        with: [{ field: skills.lore.academia.rank, as: detail }],
+        showWhen: skills.lore.academia.rank > 0,
+      }
+    skills.lore.academia.increases: { showWhen: skills.lore.academia.rank > 0 }
+    skills.lore.academia.trainedByIncrease: { showWhen: skills.lore.academia.rank > 0 }
+    skills.lore.circus.rank: { format: { bands: rank }, showWhen: skills.lore.circus.rank > 0 }
     skills.lore.circus.granted: { hidden: true }
     skills.lore.circus.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.lore.circus.mod } }] }
-    skills.lore.farming.rank: { format: { bands: rank } }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.lore.circus.mod } }],
+        with: [{ field: skills.lore.circus.rank, as: detail }],
+        showWhen: skills.lore.circus.rank > 0,
+      }
+    skills.lore.circus.increases: { showWhen: skills.lore.circus.rank > 0 }
+    skills.lore.circus.trainedByIncrease: { showWhen: skills.lore.circus.rank > 0 }
+    skills.lore.farming.rank: { format: { bands: rank }, showWhen: skills.lore.farming.rank > 0 }
     skills.lore.farming.granted: { hidden: true }
     skills.lore.farming.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.lore.farming.mod } }] }
-    skills.lore.legal.rank: { format: { bands: rank } }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.lore.farming.mod } }],
+        with: [{ field: skills.lore.farming.rank, as: detail }],
+        showWhen: skills.lore.farming.rank > 0,
+      }
+    skills.lore.farming.increases: { showWhen: skills.lore.farming.rank > 0 }
+    skills.lore.farming.trainedByIncrease: { showWhen: skills.lore.farming.rank > 0 }
+    skills.lore.legal.rank: { format: { bands: rank }, showWhen: skills.lore.legal.rank > 0 }
     skills.lore.legal.granted: { hidden: true }
     skills.lore.legal.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.lore.legal.mod } }] }
-    skills.lore.scribing.rank: { format: { bands: rank } }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.lore.legal.mod } }],
+        with: [{ field: skills.lore.legal.rank, as: detail }],
+        showWhen: skills.lore.legal.rank > 0,
+      }
+    skills.lore.legal.increases: { showWhen: skills.lore.legal.rank > 0 }
+    skills.lore.legal.trainedByIncrease: { showWhen: skills.lore.legal.rank > 0 }
+    skills.lore.scribing.rank: { format: { bands: rank }, showWhen: skills.lore.scribing.rank > 0 }
     skills.lore.scribing.granted: { hidden: true }
     skills.lore.scribing.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.lore.scribing.mod } }] }
-    skills.lore.underworld.rank: { format: { bands: rank } }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.lore.scribing.mod } }],
+        with: [{ field: skills.lore.scribing.rank, as: detail }],
+        showWhen: skills.lore.scribing.rank > 0,
+      }
+    skills.lore.scribing.increases: { showWhen: skills.lore.scribing.rank > 0 }
+    skills.lore.scribing.trainedByIncrease: { showWhen: skills.lore.scribing.rank > 0 }
+    skills.lore.underworld.rank:
+      { format: { bands: rank }, showWhen: skills.lore.underworld.rank > 0 }
     skills.lore.underworld.granted: { hidden: true }
     skills.lore.underworld.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.lore.underworld.mod } }] }
-    skills.lore.warfare.rank: { format: { bands: rank } }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.lore.underworld.mod } }],
+        with: [{ field: skills.lore.underworld.rank, as: detail }],
+        showWhen: skills.lore.underworld.rank > 0,
+      }
+    skills.lore.underworld.increases: { showWhen: skills.lore.underworld.rank > 0 }
+    skills.lore.underworld.trainedByIncrease: { showWhen: skills.lore.underworld.rank > 0 }
+    skills.lore.warfare.rank: { format: { bands: rank }, showWhen: skills.lore.warfare.rank > 0 }
     skills.lore.warfare.granted: { hidden: true }
     skills.lore.warfare.mod:
-      { format: signed, rolls: [{ action: check, params: { check: skills.lore.warfare.mod } }] }
+      {
+        format: signed,
+        rolls: [{ action: check, params: { check: skills.lore.warfare.mod } }],
+        with: [{ field: skills.lore.warfare.rank, as: detail }],
+        showWhen: skills.lore.warfare.rank > 0,
+      }
+    skills.lore.warfare.increases: { showWhen: skills.lore.warfare.rank > 0 }
+    skills.lore.warfare.trainedByIncrease: { showWhen: skills.lore.warfare.rank > 0 }

package/rules/sorcerer.yaml

@@ -1,5 +1,6 @@
 fields:
   sorcerer.bloodline:
+    open: true
     type: enum
     values:
       [none, aberrant, angelic, demonic, diabolic, draconic, elemental, fey, hag, imperial, undead]
@@ -39,10 +40,21 @@ tags:
 
 display:
   fields:
-    sorcerer.bloodline: { groups: [summary], priority: 2 }
-    sorcerer.element: { groups: [summary], priority: 2 }
+    sorcerer.bloodline: { groups: [summary], priority: 2, showWhen: class.has.sorcerer }
+    sorcerer.element:
+      { groups: [summary], priority: 2, showWhen: "sorcerer.bloodline == 'elemental'" }
     sorcerer.elementDamage: { hidden: true }
     sorcerer.gifts: { hidden: true }
-    sorcerer.evolutionSignature: { groups: [spellcasting], priority: 2 }
-    sorcerer.evolutionSpell: { groups: [spellcasting], priority: 2 }
+    sorcerer.evolutionSignature:
+      {
+        groups: [spellcasting],
+        priority: 2,
+        showWhen: '@feats.sorcerer.arcane-evolution in feats.held',
+      }
+    sorcerer.evolutionSpell:
+      {
+        groups: [spellcasting],
+        priority: 2,
+        showWhen: '@feats.sorcerer.occult-evolution in feats.held',
+      }
     sorcerer.evolutionRank: { hidden: true }

package/rules/spellcasting.yaml

@@ -269,6 +269,13 @@ situational:
     incoming: { fields: [hp.current], tags: [damage] }
     available: >-
       countList(character.applied, x.active && x.source == @spells.shield) > 0
+  - id: fireShieldBlock
+    type: boolean
+    default: false
+    incoming: { fields: [hp.current], tags: [damage] }
+    available: >-
+      shield.raised
+        && countList(character.applied, x.active && x.source == @spells.fire-shield) > 0
 
   - id: bespellStrikes
     type: boolean
@@ -292,6 +299,8 @@ contentTypes:
   spell:
     texts: [trigger, requirements]
     fields:
+      # An initial domain spell's domain.
+      domain: { type: id, of: domain }
       rank: { type: integer, required: true, min: 1, max: 10 }
       cast:
         type: enum
@@ -340,6 +349,7 @@ contentTypes:
       damage: { type: dice, default: 0d6 }
       damageBonus: { type: integer, default: 0 }
       damageType:
+        open: true
         type: enum
         values:
           [
@@ -364,6 +374,7 @@ contentTypes:
       damageTypeChoice: { type: boolean, default: false }
       damage2: { type: dice, default: 0d6 }
       damage2Type:
+        open: true
         type: enum
         values:
           [
@@ -393,6 +404,7 @@ contentTypes:
       persistent: { type: dice, default: 0d6 }
       persistentBonus: { type: integer, default: 0, min: 0 }
       persistentType:
+        open: true
         type: enum
         values:
           [
@@ -440,7 +452,7 @@ contentTypes:
       applyTo: { type: enum, values: [none, self, ally, target], default: none }
       applyAt: { type: integer, default: 2, min: 1, max: 3 }
       stabilizes: { type: boolean, default: false }
-      copyTemplates: { type: set, of: string }
+      copyTemplates: { type: list, of: string, unique: true }
     # An applied spell's `outcome` is the target's: 1 success, 2 failure, 3 critical failure.
     state:
       rank: { type: integer, default: item.rank, min: 1, max: 10 }
@@ -451,6 +463,7 @@ contentTypes:
       outcome: { type: integer, default: 2, min: 0, max: 3 }
       value: { type: integer, default: 1, min: 0 }
       damageType:
+        open: true
         type: enum
         values:
           [
@@ -489,6 +502,7 @@ actions:
       damageType:
         type: enum
         optional: true
+        open: true
         values:
           [
             acid,
@@ -1242,13 +1256,13 @@ actions:
             key: expended
             value: false
           - type: setState
-            when: "countCopies(copy.type == 'class' && has(copy.state.bondDrained) && copy.state.bondDrained > 0) > 0"
-            copies: { type: class, where: 'has(self.bondDrained) && self.bondDrained > 0' }
+            when: class.has.wizard
+            grants: { where: self.bondDrained > 0 }
             key: bondDrained
             value: 0
           - type: setState
-            when: "countCopies(copy.type == 'class' && has(copy.state.linkedFocusUsed) && copy.state.linkedFocusUsed) > 0"
-            copies: { type: class, where: 'has(self.linkedFocusUsed) && self.linkedFocusUsed' }
+            when: class.has.wizard
+            grants: { where: self.linkedFocusUsed }
             key: linkedFocusUsed
             value: false
       - id: items
@@ -1880,39 +1894,102 @@ display:
       }
     spells.autoRank: { groups: [spellcasting], priority: 2 }
     spellcasting.maxRank: { groups: [spell-slots], priority: 1 }
-    spellcasting.font: { groups: [spellcasting], priority: 1 }
-    spellcasting.fontSlots: { groups: [spell-slots], priority: 1 }
-    spellcasting.fontRank: { groups: [spell-slots], priority: 1 }
-    spellSlots.rank1.max: { groups: [spell-slots], priority: 0 }
+    spellcasting.font:
+      { groups: [spellcasting], priority: 1, showWhen: "spellcasting.font != 'none'" }
+    spellcasting.fontSlots:
+      { groups: [spell-slots], priority: 1, showWhen: spellcasting.fontSlots > 0 }
+    spellcasting.fontRank:
+      { groups: [spell-slots], priority: 1, showWhen: spellcasting.fontSlots > 0 }
+    spellSlots.rank1.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank1.max > 0 }
     spellSlots.rank1.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank1.max, as: max }] }
-    spellSlots.rank2.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank1.max > 0,
+        with: [{ field: spellSlots.rank1.max, as: max }],
+      }
+    spellSlots.rank2.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank2.max > 0 }
     spellSlots.rank2.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank2.max, as: max }] }
-    spellSlots.rank3.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank2.max > 0,
+        with: [{ field: spellSlots.rank2.max, as: max }],
+      }
+    spellSlots.rank3.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank3.max > 0 }
     spellSlots.rank3.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank3.max, as: max }] }
-    spellSlots.rank4.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank3.max > 0,
+        with: [{ field: spellSlots.rank3.max, as: max }],
+      }
+    spellSlots.rank4.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank4.max > 0 }
     spellSlots.rank4.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank4.max, as: max }] }
-    spellSlots.rank5.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank4.max > 0,
+        with: [{ field: spellSlots.rank4.max, as: max }],
+      }
+    spellSlots.rank5.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank5.max > 0 }
     spellSlots.rank5.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank5.max, as: max }] }
-    spellSlots.rank6.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank5.max > 0,
+        with: [{ field: spellSlots.rank5.max, as: max }],
+      }
+    spellSlots.rank6.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank6.max > 0 }
     spellSlots.rank6.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank6.max, as: max }] }
-    spellSlots.rank7.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank6.max > 0,
+        with: [{ field: spellSlots.rank6.max, as: max }],
+      }
+    spellSlots.rank7.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank7.max > 0 }
     spellSlots.rank7.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank7.max, as: max }] }
-    spellSlots.rank8.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank7.max > 0,
+        with: [{ field: spellSlots.rank7.max, as: max }],
+      }
+    spellSlots.rank8.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank8.max > 0 }
     spellSlots.rank8.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank8.max, as: max }] }
-    spellSlots.rank9.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank8.max > 0,
+        with: [{ field: spellSlots.rank8.max, as: max }],
+      }
+    spellSlots.rank9.max: { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank9.max > 0 }
     spellSlots.rank9.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank9.max, as: max }] }
-    spellSlots.rank10.max: { groups: [spell-slots], priority: 0 }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank9.max > 0,
+        with: [{ field: spellSlots.rank9.max, as: max }],
+      }
+    spellSlots.rank10.max:
+      { groups: [spell-slots], priority: 0, showWhen: spellSlots.rank10.max > 0 }
     spellSlots.rank10.used:
-      { groups: [spell-slots], priority: 0, with: [{ field: spellSlots.rank10.max, as: max }] }
+      {
+        groups: [spell-slots],
+        priority: 0,
+        showWhen: spellSlots.rank10.max > 0,
+        with: [{ field: spellSlots.rank10.max, as: max }],
+      }
+    spellSlots.extra.max: { groups: [spell-slots], priority: 1, showWhen: spellSlots.extra.max > 0 }
+    spellSlots.extra.used:
+      {
+        groups: [spell-slots],
+        priority: 1,
+        showWhen: spellSlots.extra.max > 0,
+        with: [{ field: spellSlots.extra.max, as: max }, { field: spells.extraSlot, as: detail }],
+      }
+    spells.extraSlot: { groups: [spell-slots], priority: 1, showWhen: spellSlots.extra.max > 0 }
     spellcasting.attribute: { hidden: true }
     spellcasting.proficiency: { hidden: true }
     spellcasting.attributeMod: { hidden: true }

package/rules/spells-high.yaml

@@ -11,7 +11,7 @@ tags:
 
 display:
   fields:
-    speed.fly: { groups: [summary], priority: 2, unit: ft }
-    speed.climb: { groups: [summary], priority: 2, unit: ft }
+    speed.fly: { groups: [summary], priority: 2, unit: ft, showWhen: speed.fly > 0 }
+    speed.climb: { groups: [summary], priority: 2, unit: ft, showWhen: speed.climb > 0 }
     speed.climb.base: { hidden: true }
-    speed.burrow: { groups: [summary], priority: 2, unit: ft }
+    speed.burrow: { groups: [summary], priority: 2, unit: ft, showWhen: speed.burrow > 0 }

package/rules/strikes.yaml

@@ -32,6 +32,7 @@ contentTypes:
     fields:
       category: { type: enum, values: [unarmed, simple, martial, advanced], required: true }
       group:
+        open: true
         type: enum
         values:
           [
@@ -57,7 +58,8 @@ contentTypes:
       ownDice: { type: boolean, default: false }
       formAttack: { type: boolean, default: false }
       formDamage: { type: integer, default: 0 }
-      damageType: { type: enum, values: [bludgeoning, piercing, slashing, fire], required: true }
+      damageType:
+        { type: enum, values: [bludgeoning, piercing, slashing, fire], required: true, open: true }
       hands: { type: integer, default: 1, min: 1, max: 2 }
       range: { type: integer, default: 0, min: 0 }
       thrown: { type: integer, default: 0, min: 0 }

package/rules/swashbuckler.yaml

@@ -1,6 +1,7 @@
 fields:
   panache.active: { type: boolean, formula: false }
   swashbuckler.style:
+    open: true
     type: enum
     values: [none, battledancer, braggart, fencer, gymnast, rascal, wit]
     formula: "'none'"
@@ -31,21 +32,7 @@ display:
     swashbuckler.styleSkill: { hidden: true }
     swashbuckler.trickSkills: { hidden: true }
     swashbuckler.trickIncreases: { hidden: true }
-    panache.active:
-      {
-        groups: [turn],
-        priority: 0,
-        showWhen: 'countCopies(copy.item == @classes.swashbuckler) > 0',
-      }
-    swashbuckler.style:
-      {
-        groups: [summary],
-        priority: 2,
-        showWhen: 'countCopies(copy.item == @classes.swashbuckler) > 0',
-      }
+    panache.active: { groups: [turn], priority: 0, showWhen: class.has.swashbuckler }
+    swashbuckler.style: { groups: [summary], priority: 2, showWhen: class.has.swashbuckler }
     swashbuckler.preciseStrike:
-      {
-        groups: [proficiencies],
-        priority: 2,
-        showWhen: 'countCopies(copy.item == @classes.swashbuckler) > 0',
-      }
+      { groups: [proficiencies], priority: 2, showWhen: class.has.swashbuckler }

package/rules/tags.yaml

@@ -138,7 +138,13 @@ tags:
   - turn.start
   - turn.end
   - creation
+  - creation.ancestry
+  - creation.heritage
+  - creation.background
+  - creation.class
+  - creation.finish
   - level-up
+  - level-up.gain
   - turn
   - condition
   - dying

package/rules/witch.yaml

@@ -2,6 +2,7 @@
 # from them as a wizard does.
 fields:
   witch.patron:
+    open: true
     type: enum
     values:
       [
@@ -40,5 +41,5 @@ situational:
 
 display:
   fields:
-    witch.patron: { groups: [summary], priority: 2 }
+    witch.patron: { groups: [summary], priority: 2, showWhen: class.has.witch }
     witch.majorLessons: { hidden: true }