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

package/content/classes/ranger.yaml

@@ -2,6 +2,17 @@ id: classes.ranger
 type: class
 fields:
   hitDie: 1d10
+  startingKit: true
+  abilityPriority:
+    [
+      abilities.dex.score,
+      abilities.wis.score,
+      abilities.con.score,
+      abilities.str.score,
+      abilities.int.score,
+      abilities.cha.score,
+    ]
+  multiclassAll: [dex, wis]
 prerequisites:
   - id: multiclass
     when: (self.startingClass && self.level == level.total) || item.id in multiclass.qualified
@@ -88,3 +99,61 @@ choices:
   - id: ranger-archetype
     from: { type: subclass, where: 'item.class == @classes.ranger' }
     when: self.level >= 3
+actions:
+  - id: kit
+    listed: false
+    params:
+      random: { type: boolean, default: false }
+    steps:
+      - id: rangerArmor
+        kind: choice
+        options:
+          - id: scale-mail
+            changes:
+              - { type: addItem, entry: { item: "'armor.scale-mail'", equipped: true } }
+          - id: leather-armor
+            changes:
+              - { type: addItem, entry: { item: "'armor.leather'", equipped: true } }
+        recommend: options[0]
+        random: params.random
+      - id: rangerWeapons
+        kind: choice
+        options:
+          - id: two-shortswords
+            changes:
+              - type: addItem
+                entry: { item: "'weapons.shortsword'", quantity: 2, equipped: true }
+          - id: two-simple-melee
+        recommend: options[0]
+        random: params.random
+      - id: rangerSimpleMelee
+        kind: choice
+        when: "steps.rangerWeapons.picked == 'two-simple-melee'"
+        options:
+          content: { type: weapon, where: "item.category == 'simple' && item.range == 'melee'" }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id, equipped: true } }
+      - id: rangerSimpleMelee2
+        kind: choice
+        when: "steps.rangerWeapons.picked == 'two-simple-melee'"
+        options:
+          content: { type: weapon, where: "item.category == 'simple' && item.range == 'melee'" }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id, equipped: true } }
+      - id: rangerPack
+        kind: choice
+        options:
+          - id: dungeoneers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.dungeoneers-pack'" } }]
+          - id: explorers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.explorers-pack'" } }]
+        recommend: options[0]
+        random: params.random
+      - id: rangerKit
+        kind: changes
+        changes:
+          - { type: addItem, entry: { item: "'weapons.longbow'", equipped: true } }
+          - { type: addItem, entry: { item: "'gear.quiver'" } }
+          - { type: addItem, entry: { item: "'gear.arrows'", quantity: 20 } }

package/content/classes/rogue.yaml

@@ -2,6 +2,17 @@ id: classes.rogue
 type: class
 fields:
   hitDie: 1d8
+  startingKit: true
+  abilityPriority:
+    [
+      abilities.dex.score,
+      abilities.con.score,
+      abilities.wis.score,
+      abilities.int.score,
+      abilities.cha.score,
+      abilities.str.score,
+    ]
+  multiclassAll: [dex]
 state:
   strokeOfLuckUsed: { type: boolean, default: false }
 prerequisites:
@@ -105,3 +116,51 @@ choices:
   - id: roguish-archetype
     from: { type: subclass, where: 'item.class == @classes.rogue' }
     when: self.level >= 3
+actions:
+  - id: kit
+    listed: false
+    params:
+      random: { type: boolean, default: false }
+    steps:
+      - id: rogueWeapon
+        kind: choice
+        options:
+          - id: rapier
+            changes:
+              - { type: addItem, entry: { item: "'weapons.rapier'", equipped: true } }
+          - id: shortsword
+            changes:
+              - { type: addItem, entry: { item: "'weapons.shortsword'", equipped: true } }
+        recommend: options[0]
+        random: params.random
+      - id: rogueSecond
+        kind: choice
+        options:
+          - id: shortbow
+            changes:
+              - { type: addItem, entry: { item: "'weapons.shortbow'", equipped: true } }
+              - { type: addItem, entry: { item: "'gear.quiver'" } }
+              - { type: addItem, entry: { item: "'gear.arrows'", quantity: 20 } }
+          - id: shortsword
+            changes:
+              - { type: addItem, entry: { item: "'weapons.shortsword'", equipped: true } }
+        recommend: options[0]
+        random: params.random
+      - id: roguePack
+        kind: choice
+        options:
+          - id: burglars-pack
+            changes: [{ type: addItem, entry: { item: "'gear.burglars-pack'" } }]
+          - id: dungeoneers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.dungeoneers-pack'" } }]
+          - id: explorers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.explorers-pack'" } }]
+        recommend: options[0]
+        random: params.random
+      - id: rogueKit
+        kind: changes
+        changes:
+          - { type: addItem, entry: { item: "'armor.leather'", equipped: true } }
+          - type: addItem
+            entry: { item: "'weapons.dagger'", quantity: 2, equipped: true }
+          - { type: addItem, entry: { item: "'tools.thieves-tools'" } }

package/content/classes/sorcerer.yaml

@@ -2,6 +2,17 @@ id: classes.sorcerer
 type: class
 fields:
   hitDie: 1d6
+  startingKit: true
+  abilityPriority:
+    [
+      abilities.cha.score,
+      abilities.con.score,
+      abilities.dex.score,
+      abilities.wis.score,
+      abilities.int.score,
+      abilities.str.score,
+    ]
+  multiclassAll: [cha]
 state:
   sorceryPointsSpent: { type: integer, default: 0, min: 0 }
 prerequisites:
@@ -69,3 +80,56 @@ choices:
   - id: sorcerous-origin
     from: { type: subclass, where: 'item.class == @classes.sorcerer' }
     when: self.level >= 1
+actions:
+  - id: kit
+    listed: false
+    params:
+      random: { type: boolean, default: false }
+    steps:
+      - id: sorcererWeapon
+        kind: choice
+        options:
+          - id: light-crossbow
+            changes:
+              - type: addItem
+                entry: { item: "'weapons.light-crossbow'", equipped: true }
+              - { type: addItem, entry: { item: "'gear.crossbow-bolts'", quantity: 20 } }
+          - id: simple
+        recommend: options[0]
+        random: params.random
+      - id: sorcererSimple
+        kind: choice
+        when: "steps.sorcererWeapon.picked == 'simple'"
+        options: { content: { type: weapon, where: "item.category == 'simple'" } }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id, equipped: true } }
+      - id: sorcererFocus
+        kind: choice
+        options:
+          - id: component-pouch
+            changes: [{ type: addItem, entry: { item: "'gear.component-pouch'" } }]
+          - id: arcane-focus
+        recommend: options[0]
+        random: params.random
+      - id: sorcererArcaneFocus
+        kind: choice
+        when: "steps.sorcererFocus.picked == 'arcane-focus'"
+        options: { content: { type: gear, where: "item.category == 'arcane-focus'" } }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id } }
+      - id: sorcererPack
+        kind: choice
+        options:
+          - id: dungeoneers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.dungeoneers-pack'" } }]
+          - id: explorers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.explorers-pack'" } }]
+        recommend: options[0]
+        random: params.random
+      - id: sorcererKit
+        kind: changes
+        changes:
+          - type: addItem
+            entry: { item: "'weapons.dagger'", quantity: 2, equipped: true }

package/content/classes/warlock.yaml

@@ -2,6 +2,17 @@ id: classes.warlock
 type: class
 fields:
   hitDie: 1d8
+  startingKit: true
+  abilityPriority:
+    [
+      abilities.cha.score,
+      abilities.con.score,
+      abilities.dex.score,
+      abilities.wis.score,
+      abilities.int.score,
+      abilities.str.score,
+    ]
+  multiclassAll: [cha]
 state:
   arcanum6Used: { type: boolean, default: false }
   arcanum7Used: { type: boolean, default: false }
@@ -51,3 +62,63 @@ choices:
   - id: otherworldly-patron
     from: { type: subclass, where: 'item.class == @classes.warlock' }
     when: self.level >= 1
+actions:
+  - id: kit
+    listed: false
+    params:
+      random: { type: boolean, default: false }
+    steps:
+      - id: warlockWeapon
+        kind: choice
+        options:
+          - id: light-crossbow
+            changes:
+              - type: addItem
+                entry: { item: "'weapons.light-crossbow'", equipped: true }
+              - { type: addItem, entry: { item: "'gear.crossbow-bolts'", quantity: 20 } }
+          - id: simple
+        recommend: options[0]
+        random: params.random
+      - id: warlockSimple
+        kind: choice
+        when: "steps.warlockWeapon.picked == 'simple'"
+        options: { content: { type: weapon, where: "item.category == 'simple'" } }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id, equipped: true } }
+      - id: warlockFocus
+        kind: choice
+        options:
+          - id: component-pouch
+            changes: [{ type: addItem, entry: { item: "'gear.component-pouch'" } }]
+          - id: arcane-focus
+        recommend: options[0]
+        random: params.random
+      - id: warlockArcaneFocus
+        kind: choice
+        when: "steps.warlockFocus.picked == 'arcane-focus'"
+        options: { content: { type: gear, where: "item.category == 'arcane-focus'" } }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id } }
+      - id: warlockPack
+        kind: choice
+        options:
+          - id: scholars-pack
+            changes: [{ type: addItem, entry: { item: "'gear.scholars-pack'" } }]
+          - id: dungeoneers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.dungeoneers-pack'" } }]
+        recommend: options[0]
+        random: params.random
+      - id: warlockExtra
+        kind: choice
+        options: { content: { type: weapon, where: "item.category == 'simple'" } }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id, equipped: true } }
+      - id: warlockKit
+        kind: changes
+        changes:
+          - { type: addItem, entry: { item: "'armor.leather'", equipped: true } }
+          - type: addItem
+            entry: { item: "'weapons.dagger'", quantity: 2, equipped: true }

package/content/classes/wizard.yaml

@@ -2,6 +2,17 @@ id: classes.wizard
 type: class
 fields:
   hitDie: 1d6
+  startingKit: true
+  abilityPriority:
+    [
+      abilities.int.score,
+      abilities.con.score,
+      abilities.dex.score,
+      abilities.wis.score,
+      abilities.cha.score,
+      abilities.str.score,
+    ]
+  multiclassAll: [int]
 state:
   arcaneRecoveryUsed: { type: boolean, default: false }
   overchannelUses: { type: integer, default: 0, min: 0 }
@@ -72,3 +83,48 @@ choices:
   - id: arcane-tradition
     from: { type: subclass, where: 'item.class == @classes.wizard' }
     when: self.level >= 2
+actions:
+  - id: kit
+    listed: false
+    params:
+      random: { type: boolean, default: false }
+    steps:
+      - id: wizardWeapon
+        kind: choice
+        options:
+          - id: quarterstaff
+            changes:
+              - { type: addItem, entry: { item: "'weapons.quarterstaff'", equipped: true } }
+          - id: dagger
+            changes:
+              - { type: addItem, entry: { item: "'weapons.dagger'", equipped: true } }
+        recommend: options[0]
+        random: params.random
+      - id: wizardFocus
+        kind: choice
+        options:
+          - id: component-pouch
+            changes: [{ type: addItem, entry: { item: "'gear.component-pouch'" } }]
+          - id: arcane-focus
+        recommend: options[0]
+        random: params.random
+      - id: wizardArcaneFocus
+        kind: choice
+        when: "steps.wizardFocus.picked == 'arcane-focus'"
+        options: { content: { type: gear, where: "item.category == 'arcane-focus'" } }
+        random: params.random
+        changes:
+          - { type: addItem, entry: { item: picked.id } }
+      - id: wizardPack
+        kind: choice
+        options:
+          - id: scholars-pack
+            changes: [{ type: addItem, entry: { item: "'gear.scholars-pack'" } }]
+          - id: explorers-pack
+            changes: [{ type: addItem, entry: { item: "'gear.explorers-pack'" } }]
+        recommend: options[0]
+        random: params.random
+      - id: wizardKit
+        kind: changes
+        changes:
+          - { type: addItem, entry: { item: "'gear.spellbook'" } }

package/content/features/sorcerer/dragon-ancestor.yaml

@@ -3,46 +3,4 @@ type: feature
 effects:
   - { target: proficiencies.languages, op: grant, value: { item: languages.draconic } }
 choices:
-  - id: dragon
-    from:
-      options:
-        - id: black
-          tags: [damage.acid]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'acid'" }
-        - id: blue
-          tags: [damage.lightning]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'lightning'" }
-        - id: brass
-          tags: [damage.fire]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'fire'" }
-        - id: bronze
-          tags: [damage.lightning]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'lightning'" }
-        - id: copper
-          tags: [damage.acid]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'acid'" }
-        - id: gold
-          tags: [damage.fire]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'fire'" }
-        - id: green
-          tags: [damage.poison]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'poison'" }
-        - id: red
-          tags: [damage.fire]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'fire'" }
-        - id: silver
-          tags: [damage.cold]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'cold'" }
-        - id: white
-          tags: [damage.cold]
-          effects:
-            - { target: draconic.damageType, op: set, value: "'cold'" }
+  - { id: dragon, from: { type: draconicAncestry }, activate: false }

package/content/features/sorcerer/elemental-affinity.yaml

@@ -4,34 +4,55 @@ effects:
   - target: { rolls: [damage.spell] }
     op: add
     value: abilities.cha.mod
-    tags: [{ formula: "'damage.' + draconic.damageType" }]
-    when: has(roll.item.damageType) && roll.item.damageType == draconic.damageType
+    tags:
+      - formula: >-
+          mapList(picksOf('features.sorcerer.dragon-ancestor', 'dragon'),
+            'damage.' + itemField(x, 'damageType'))
+    when: >-
+      has(roll.item.damageType)
+        && roll.item.damageType in mapList(picksOf('features.sorcerer.dragon-ancestor', 'dragon'),
+          itemField(x, 'damageType'))
   - target: { incoming: { fields: [hp.current], tags: [damage.acid] } }
     op: multiply
     value: 0.5
-    when: elementalAffinity.resistant && draconic.damageType == 'acid'
+    when: >-
+      elementalAffinity.resistant
+        && 'acid' in mapList(picksOf('features.sorcerer.dragon-ancestor', 'dragon'),
+          itemField(x, 'damageType'))
   - target: { incoming: { fields: [hp.current], tags: [damage.cold] } }
     op: multiply
     value: 0.5
-    when: elementalAffinity.resistant && draconic.damageType == 'cold'
+    when: >-
+      elementalAffinity.resistant
+        && 'cold' in mapList(picksOf('features.sorcerer.dragon-ancestor', 'dragon'),
+          itemField(x, 'damageType'))
   - target: { incoming: { fields: [hp.current], tags: [damage.fire] } }
     op: multiply
     value: 0.5
-    when: elementalAffinity.resistant && draconic.damageType == 'fire'
+    when: >-
+      elementalAffinity.resistant
+        && 'fire' in mapList(picksOf('features.sorcerer.dragon-ancestor', 'dragon'),
+          itemField(x, 'damageType'))
   - target: { incoming: { fields: [hp.current], tags: [damage.lightning] } }
     op: multiply
     value: 0.5
-    when: elementalAffinity.resistant && draconic.damageType == 'lightning'
+    when: >-
+      elementalAffinity.resistant
+        && 'lightning' in mapList(picksOf('features.sorcerer.dragon-ancestor', 'dragon'),
+          itemField(x, 'damageType'))
   - target: { incoming: { fields: [hp.current], tags: [damage.poison] } }
     op: multiply
     value: 0.5
-    when: elementalAffinity.resistant && draconic.damageType == 'poison'
+    when: >-
+      elementalAffinity.resistant
+        && 'poison' in mapList(picksOf('features.sorcerer.dragon-ancestor', 'dragon'),
+          itemField(x, 'damageType'))
 actions:
   - id: elemental-resistance
     tags: [feature]
     results: [resistant]
     available: >-
-      draconic.damageType != 'none' && !elementalAffinity.resistant
+      size(picksOf('features.sorcerer.dragon-ancestor', 'dragon')) > 0 && !elementalAffinity.resistant
         && self.sorceryPointsSpent < sorcery.points
     steps:
       - id: spend

package/content/features/sorcerer/metamagic.yaml

@@ -1,98 +1,6 @@
 id: features.sorcerer.metamagic
 type: feature
-# Empowered Spell rerolls, once, the lowest damage dice at or below half their faces, up to the
-# Charisma modifier (at least one).
-effects:
-  - target: { rolls: [damage.spell] }
-    op: rollModifier
-    value:
-      kind: reroll
-      below: 'floor(maxOf(dieOf(roll.item.damage)) / 2)'
-      once: true
-      count: max(1, abilities.cha.mod)
-    when: >-
-      has(flags.metamagic) && flags.metamagic == 'empowered' && has(roll.item.damage)
 choices:
   - id: options
     pick: 'self.level >= 17 ? 4 : self.level >= 10 ? 3 : 2'
-    from:
-      options:
-        - { id: careful-spell }
-        - { id: distant-spell }
-        - { id: empowered-spell }
-        - { id: extended-spell }
-        - { id: heightened-spell }
-        - { id: quickened-spell }
-        - { id: subtle-spell }
-        - { id: twinned-spell }
-    effects:
-      - { target: sorcery.metamagic, op: set, value: sorcery.left > 0 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'careful-spell' && has(action.item.save) && sorcery.left >= 1"
-        value:
-          id: careful
-          flags: { metamagic: "'careful'" }
-          changes:
-            - { type: adjustState, entry: self, key: sorceryPointsSpent, by: 1 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'distant-spell' && sorcery.left >= 1"
-        value:
-          id: distant
-          flags: { metamagic: "'distant'" }
-          changes:
-            - { type: adjustState, entry: self, key: sorceryPointsSpent, by: 1 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'empowered-spell' && has(action.item.damage) && sorcery.left >= 1"
-        value:
-          id: empowered
-          flags: { metamagic: "'empowered'" }
-          changes:
-            - { type: adjustState, entry: self, key: sorceryPointsSpent, by: 1 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'extended-spell' && sorcery.left >= 1"
-        value:
-          id: extended
-          flags: { metamagic: "'extended'" }
-          changes:
-            - { type: adjustState, entry: self, key: sorceryPointsSpent, by: 1 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'heightened-spell' && has(action.item.save) && sorcery.left >= 3"
-        value:
-          id: heightened
-          flags: { metamagic: "'heightened'" }
-          changes:
-            - { type: adjustState, entry: self, key: sorceryPointsSpent, by: 3 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'quickened-spell' && sorcery.left >= 2"
-        value:
-          id: quickened
-          flags: { metamagic: "'quickened'" }
-          changes:
-            - { type: adjustState, entry: self, key: sorceryPointsSpent, by: 2 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'subtle-spell' && sorcery.left >= 1"
-        value:
-          id: subtle
-          flags: { metamagic: "'subtle'" }
-          changes:
-            - { type: adjustState, entry: self, key: sorceryPointsSpent, by: 1 }
-      - target: { choices: [metamagic] }
-        op: option
-        when: "pick.id == 'twinned-spell' && sorcery.left >= max(1, action.item.level)"
-        value:
-          id: twinned
-          flags: { metamagic: "'twinned'" }
-          changes:
-            - {
-                type: adjustState,
-                entry: self,
-                key: sorceryPointsSpent,
-                by: 'max(1, action.item.level)',
-              }
+    from: { type: metamagic }

package/content/features/wizard/arcane-recovery.yaml

@@ -16,9 +16,9 @@ actions:
         options:
           values: [1, 2, 3, 4, 5]
           where: >-
-            picks < fieldOf('spellSlots.level{slot}.used', value)
-              && value + sumList(steps.slots.picked, indexOf(['1', '2', '3', '4', '5'], x) + 1)
-                <= ceil(self.level / 2)
+            countList(steps.slots.values, x == value)
+                < fieldOf('spellSlots.level{slot}.used', value)
+              && sumList(steps.slots.values, x) + value <= ceil(self.level / 2)
         repeat: { max: ceil(self.level / 2), min: 1 }
         prefer: value
         changes:
@@ -33,4 +33,4 @@ actions:
         kind: outcome
         result: "'recovered'"
         data:
-          levels: sumList(steps.slots.picked, indexOf(['1', '2', '3', '4', '5'], x) + 1)
+          levels: sumList(steps.slots.values, x)

package/content/hunter-tactics/colossus-slayer.yaml

@@ -0,0 +1,4 @@
+id: hunter-tactics.colossus-slayer
+type: hunterTactic
+fields:
+  feature: hunters-prey

package/content/hunter-tactics/escape-the-horde.yaml

@@ -0,0 +1,4 @@
+id: hunter-tactics.escape-the-horde
+type: hunterTactic
+fields:
+  feature: defensive-tactics

package/content/hunter-tactics/evasion.yaml

@@ -0,0 +1,6 @@
+id: hunter-tactics.evasion
+type: hunterTactic
+fields:
+  feature: superior-hunters-defense
+grants:
+  - { item: features.evasion }

package/content/hunter-tactics/giant-killer.yaml

@@ -0,0 +1,4 @@
+id: hunter-tactics.giant-killer
+type: hunterTactic
+fields:
+  feature: hunters-prey

package/content/hunter-tactics/horde-breaker.yaml

@@ -0,0 +1,4 @@
+id: hunter-tactics.horde-breaker
+type: hunterTactic
+fields:
+  feature: hunters-prey

package/content/hunter-tactics/multiattack-defense.yaml

@@ -0,0 +1,4 @@
+id: hunter-tactics.multiattack-defense
+type: hunterTactic
+fields:
+  feature: defensive-tactics

package/content/hunter-tactics/stand-against-the-tide.yaml

@@ -0,0 +1,4 @@
+id: hunter-tactics.stand-against-the-tide
+type: hunterTactic
+fields:
+  feature: superior-hunters-defense

package/content/hunter-tactics/steel-will.yaml

@@ -0,0 +1,4 @@
+id: hunter-tactics.steel-will
+type: hunterTactic
+fields:
+  feature: defensive-tactics

package/content/hunter-tactics/uncanny-dodge.yaml

@@ -0,0 +1,6 @@
+id: hunter-tactics.uncanny-dodge
+type: hunterTactic
+fields:
+  feature: superior-hunters-defense
+grants:
+  - { item: features.rogue.uncanny-dodge }

package/content/hunter-tactics/volley.yaml

@@ -0,0 +1,6 @@
+id: hunter-tactics.volley
+type: hunterTactic
+fields:
+  feature: multiattack
+grants:
+  - { item: features.ranger.volley }

package/content/hunter-tactics/whirlwind-attack.yaml

@@ -0,0 +1,6 @@
+id: hunter-tactics.whirlwind-attack
+type: hunterTactic
+fields:
+  feature: multiattack
+grants:
+  - { item: features.ranger.whirlwind-attack }