@opencharacter/orc-sf-2e 0.1.1 → 0.3.0

package/rules/solarian.yaml

@@ -28,8 +28,7 @@ tags:
 
 display:
   fields:
-    solarian.attunement:
-      { groups: [turn], priority: 0, showWhen: 'countCopies(copy.item == @classes.solarian) > 0' }
+    solarian.attunement: { groups: [turn], priority: 0, showWhen: class.has.solarian }
     solarian.perfect: { hidden: true }
     solarian.rampart: { hidden: true }
     solarian.forms: { hidden: true }

package/rules/spellcasting.yaml

@@ -250,6 +250,7 @@ contentTypes:
       damage: { type: dice, default: 0d6 }
       damageBonus: { type: integer, default: 0 }
       damageType:
+        open: true
         type: enum
         values:
           [
@@ -274,6 +275,7 @@ contentTypes:
       damageTypeChoice: { type: boolean, default: false }
       damage2: { type: dice, default: 0d6 }
       damage2Type:
+        open: true
         type: enum
         values:
           [
@@ -303,6 +305,7 @@ contentTypes:
       persistent: { type: dice, default: 0d6 }
       persistentBonus: { type: integer, default: 0, min: 0 }
       persistentType:
+        open: true
         type: enum
         values:
           [
@@ -350,13 +353,14 @@ 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 }
     state:
       rank: { type: integer, default: item.rank, min: 1, max: 10 }
       source: { type: string, default: '' }
       outcome: { type: integer, default: 2, min: 0, max: 3 }
       value: { type: integer, default: 1, min: 0 }
       damageType:
+        open: true
         type: enum
         values:
           [
@@ -379,6 +383,7 @@ contentTypes:
         default: fire
       copy: { type: string, default: '' }
       form: { type: string, default: '' }
+      element: { type: string, default: '' }
     actions:
       - use: cast-spell
 
@@ -391,10 +396,12 @@ actions:
       ac: { type: integer, optional: true }
       copy: { type: string, optional: true }
       form: { type: string, optional: true }
+      element: { type: enum, optional: true, values: [air, earth, fire, metal, water, wood] }
       source: { type: string, optional: true }
       damageType:
         type: enum
         optional: true
+        open: true
         values:
           [
             acid,
@@ -891,6 +898,7 @@ actions:
               damageType: flags.damageType
               copy: flags.copy
               form: "has(params.form) ? params.form : ''"
+              element: "has(params.element) ? params.element : ''"
       - id: onCaster
         kind: changes
         tags: [spell.caster]
@@ -1004,10 +1012,6 @@ actions:
           - { type: set, when: focus.spent > 0, field: focus.spent, value: 0 }
           - { type: set, when: vitality.spent > 0, field: vitality.spent, value: 0 }
           - { type: setState, picks: { where: self.used }, key: used, value: false }
-          - type: setState
-            picks: { where: has(self.fanUses) && self.fanUses > 0 }
-            key: fanUses
-            value: 0
           - type: set
             forEach: keysOf('archetypeSource')
             when: fieldOf('spellSlots.archetype.{archetypeSource}.rank{archetypeRank}.used', x, 1) > 0
@@ -1156,36 +1160,96 @@ display:
       }
     spells.autoRank: { groups: [spellcasting], priority: 2 }
     spellcasting.maxRank: { groups: [spell-slots], priority: 1 }
-    spellSlots.rank1.max: { groups: [spell-slots], priority: 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

@@ -44,6 +44,7 @@ contentTypes:
     fields:
       category: { type: enum, values: [unarmed, simple, martial, advanced], required: true }
       group:
+        open: true
         type: enum
         values:
           [
@@ -78,6 +79,7 @@ contentTypes:
       formAttack: { type: boolean, default: false }
       formDamage: { type: integer, default: 0 }
       damageType:
+        open: true
         type: enum
         values:
           [acid, bludgeoning, cold, electricity, fire, mental, piercing, slashing, sonic, void]
@@ -94,7 +96,7 @@ contentTypes:
       reload: { type: integer, min: 0 }
       boost: { type: dice }
       magazine: { type: integer, default: 0, min: 0 }
-      ammoKind: { type: enum, values: [none, rounds, charges, chems], default: none }
+      ammoKind: { type: enum, values: [none, rounds, charges, chems], default: none, open: true }
       expend: { type: integer, default: 1, min: 0 }
       area: { type: enum, values: [none, burst, cone, line], default: none }
       areaSize: { type: integer, default: 0, min: 0 }
@@ -293,97 +295,12 @@ actions:
     steps:
       - id: type
         kind: choice
-        options:
-          - id: acid
-            when: "item.damageType == 'acid' || 'acid' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'acid' ? '' : 'acid'",
-                }
-          - id: bludgeoning
-            when: "item.damageType == 'bludgeoning' || 'bludgeoning' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'bludgeoning' ? '' : 'bludgeoning'",
-                }
-          - id: cold
-            when: "item.damageType == 'cold' || 'cold' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'cold' ? '' : 'cold'",
-                }
-          - id: electricity
-            when: "item.damageType == 'electricity' || 'electricity' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'electricity' ? '' : 'electricity'",
-                }
-          - id: fire
-            when: "item.damageType == 'fire' || 'fire' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'fire' ? '' : 'fire'",
-                }
-          - id: mental
-            when: "item.damageType == 'mental' || 'mental' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'mental' ? '' : 'mental'",
-                }
-          - id: piercing
-            when: "item.damageType == 'piercing' || 'piercing' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'piercing' ? '' : 'piercing'",
-                }
-          - id: slashing
-            when: "item.damageType == 'slashing' || 'slashing' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'slashing' ? '' : 'slashing'",
-                }
-          - id: sonic
-            when: "item.damageType == 'sonic' || 'sonic' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'sonic' ? '' : 'sonic'",
-                }
-          - id: void
-            when: "item.damageType == 'void' || 'void' in item.modularTypes"
-            changes:
-              - {
-                  type: setState,
-                  entry: self,
-                  key: modular,
-                  value: "item.damageType == 'void' ? '' : 'void'",
-                }
+        options: { values: { formula: '[item.damageType] + item.modularTypes' } }
+        changes:
+          - type: setState
+            entry: self
+            key: modular
+            value: "picked.value == item.damageType ? '' : picked.value"
       - id: result
         kind: outcome
         result: "'switched'"

package/rules/tags.yaml

@@ -145,7 +145,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/witchwarper.yaml

@@ -1,6 +1,11 @@
 fields:
   witchwarper.paradox:
-    { type: enum, values: [none, analyst, anomaly, lost-history, precog], formula: "'none'" }
+    {
+      type: enum,
+      values: [none, analyst, anomaly, lost-history, precog],
+      formula: "'none'",
+      open: true,
+    }
   quantum.active: { type: boolean, input: true, default: false }
   quantum.radius: { type: integer, formula: 20, min: 0 }
   witchwarper.memorySkill: { type: string, input: true, default: '' }
@@ -9,12 +14,7 @@ fields:
 display:
   fields:
     witchwarper.paradox: { hidden: true }
-    quantum.active:
-      {
-        groups: [turn],
-        priority: 0,
-        showWhen: 'countCopies(copy.item == @classes.witchwarper) > 0',
-      }
+    quantum.active: { groups: [turn], priority: 0, showWhen: class.has.witchwarper }
     witchwarper.memorySkill: { hidden: true }
     witchwarper.otherLife: { hidden: true }
     quantum.radius: { groups: [turn], priority: 1, showWhen: quantum.active }

package/upgrades/0.1.1-to-0.2.0.yaml

@@ -0,0 +1,18 @@
+pack: orc-sf-2e
+from: 0.1.1
+to: 0.2.0
+steps:
+  # Assurance's skill was grant state; it is a pick now, preset by the granting content.
+  - { op: removeState, type: feat, key: skill }
+  # Fixation's Lore was the granted Additional Lore's own choice, saved in Fixation's pick; it is
+  # Fixation's topic now, with the same options, which presets Additional Lore and Assurance.
+  - op: renameChoice
+    owner: feats.ancestry.fixation
+    from: orc-sf-2e:feats.skill.additional-lore/lore
+    to: topic
+  # Warblood vesk's attack was the granted Brutal Anatomy's own choice, saved in the heritage's
+  # pick; the heritage picks two attacks now, with the same options. The second is pending.
+  - op: renameChoice
+    owner: heritages.warblood-vesk
+    from: orc-sf-2e:feats.ancestry.brutal-anatomy/attack
+    to: attacks

package/upgrades/0.2.0-to-0.3.0.yaml

@@ -0,0 +1,12 @@
+pack: orc-sf-2e
+from: 0.2.0
+to: 0.3.0
+steps:
+  # Fixation's topic presets nothing now: its granted Additional Lore asks the Lore itself, with
+  # the same values, and Assurance follows that pick.
+  - op: renameChoice
+    owner: feats.ancestry.fixation
+    from: topic
+    to: orc-sf-2e:feats.skill.additional-lore/lore
+  # Harmonic Sensitivity asks whether it trains Performance or gives Assurance in it.
+  - { op: requireChoice, owner: feats.ancestry.harmonic-sensitivity, choice: harmonic }