@opencharacter/orc-2e 0.2.0 → 0.3.0

package/rules/monk.yaml

@@ -1,5 +1,6 @@
 fields:
   stance.current:
+    open: true
     type: enum
     values: [none, cobra, crane, dragon, mountain, tiger, wolf, clinging-shadows, wild-winds]
     formula: "'none'"
@@ -65,9 +66,5 @@ tags:
 display:
   fields:
     stance.current:
-      {
-        groups: [turn],
-        priority: 1,
-        showWhen: "stance.current != 'none' || countCopies(copy.item == @classes.monk) > 0",
-      }
+      { groups: [turn], priority: 1, showWhen: "stance.current != 'none' || class.has.monk" }
     monk.paths: { hidden: true }

package/rules/oracle.yaml

@@ -1,11 +1,13 @@
 fields:
   oracle.mystery:
+    open: true
     type: enum
     values: [none, ancestors, battle, bones, cosmos, flames, life, lore, tempest]
     formula: "'none'"
   oracle.cursebound: { type: integer, input: true, default: 0, min: 0, max: oracle.curseMax }
   oracle.curseMax: { type: integer, formula: 'level >= 17 ? 4 : level >= 11 ? 3 : 2' }
   oracle.granted: { type: set, of: spell }
+  oracle.domains: { type: set, of: domain }
   oracle.revelations: { type: set, of: spell }
   oracle.grantedFeats: { type: set, of: feat }
 
@@ -19,8 +21,7 @@ situational:
     rolls: [save]
     available: >-
       oracle.mystery == 'battle' || countCopies(copy.type == 'shield' && copy.equipped
-        && copy.item in [@shields.specific.spellguard-shield,
-          @shields.specific.reflecting-shield]) > 0
+        && 'shield.against-spells' in copy.tags) > 0
   - id: divineAegis
     type: enum
     values: [none, nondivine, divine]
@@ -41,7 +42,7 @@ situational:
 
 display:
   fields:
-    oracle.mystery: { groups: [summary], priority: 2 }
+    oracle.mystery: { groups: [summary], priority: 2, showWhen: class.has.oracle }
     oracle.cursebound:
       groups: [spellcasting]
       priority: 0
@@ -49,5 +50,6 @@ display:
       with: [{ field: oracle.curseMax, as: max }]
     oracle.curseMax: { groups: [spellcasting], priority: 2, showWhen: "oracle.mystery != 'none'" }
     oracle.granted: { hidden: true }
+    oracle.domains: { hidden: true }
     oracle.revelations: { hidden: true }
     oracle.grantedFeats: { hidden: true }

package/rules/ranger.yaml

@@ -2,7 +2,8 @@ fields:
   # A Strike's roll effects compare it with the target's ID; checks, which have no target, use
   # `huntedPrey`.
   prey.target: { type: string, input: true, default: '' }
-  ranger.edge: { type: enum, values: [none, flurry, outwit, precision], formula: "'none'" }
+  ranger.edge:
+    { type: enum, values: [none, flurry, outwit, precision], formula: "'none'", open: true }
   twinParry.active: { type: boolean, input: true, default: false }
   prey.hits: { type: integer, input: true, default: 0, min: 0 }
 
@@ -59,8 +60,7 @@ tags:
 
 display:
   fields:
-    prey.target:
-      { groups: [turn], priority: 1, showWhen: 'countCopies(copy.item == @classes.ranger) > 0' }
+    prey.target: { groups: [turn], priority: 1, showWhen: class.has.ranger }
     twinParry.active:
       {
         groups: [defenses],

package/rules/rogue.yaml

@@ -1,6 +1,11 @@
 fields:
   rogue.racket:
-    { type: enum, values: [none, mastermind, ruffian, scoundrel, thief], formula: "'none'" }
+    {
+      type: enum,
+      values: [none, mastermind, ruffian, scoundrel, thief],
+      formula: "'none'",
+      open: true,
+    }
   sneakAttack.dice: { type: integer, formula: 0, min: 0 }
   nimbleDodge.active: { type: boolean, input: true, default: false }
 

package/rules/skill-actions-athletics.yaml

@@ -273,8 +273,7 @@ actions:
             flags:
               map: '5 * min(2, has(params.attack) ? params.attack - 1 : turn.attacks)'
               crowbar: >-
-                countCopies(copy.item == @gear.crowbar
-                  || copy.item == @gear.crowbar-levered) > 0
+                countCopies('tool.crowbar' in copy.tags) > 0
       - id: check
         kind: action
         use: check

package/rules/skill-actions-stealth.yaml

@@ -353,8 +353,7 @@ actions:
           - when: true
             flags:
               compass: >-
-                countCopies(copy.item == @gear.compass
-                  || copy.item == @gear.compass-lensatic) > 0
+                countCopies('tool.compass' in copy.tags) > 0
       - id: check
         kind: action
         use: check

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

@@ -299,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
@@ -347,6 +349,7 @@ contentTypes:
       damage: { type: dice, default: 0d6 }
       damageBonus: { type: integer, default: 0 }
       damageType:
+        open: true
         type: enum
         values:
           [
@@ -371,6 +374,7 @@ contentTypes:
       damageTypeChoice: { type: boolean, default: false }
       damage2: { type: dice, default: 0d6 }
       damage2Type:
+        open: true
         type: enum
         values:
           [
@@ -400,6 +404,7 @@ contentTypes:
       persistent: { type: dice, default: 0d6 }
       persistentBonus: { type: integer, default: 0, min: 0 }
       persistentType:
+        open: true
         type: enum
         values:
           [
@@ -447,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 }
@@ -458,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:
           [
@@ -496,6 +502,7 @@ actions:
       damageType:
         type: enum
         optional: true
+        open: true
         values:
           [
             acid,
@@ -1887,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 }