feat(book): categorize active abilities

src/main/java/games/dmg/fantasystick/FantasyStickPlugin.java

@@ -69,6 +69,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.ability.AbilityRegistry abilityRegistry;
     private games.dmg.fantasystick.ability.AbilityEngine abilityEngine;
     private games.dmg.fantasystick.ability.Fireball fireball;
+    private games.dmg.fantasystick.persistence.FireballSettings fireballSettings;
     private games.dmg.fantasystick.ability.FrostShard frostShard;
     private games.dmg.fantasystick.persistence.FrostShardSettings frostShardSettings;
     private games.dmg.fantasystick.ability.Longbow longbow;
@@ -186,7 +187,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 getConfig().get(games.dmg.fantasystick.persistence.SheetResourcePackSettings.SHA1_KEY), sheetPackDefaults);
             var rules = progressionRules();
             var rewardRules = combatRewardRules();
-            var fireballSettings = fireballSettings();
+            var fireballConfiguration = fireballConfiguration();
+            var fireballInitial = games.dmg.fantasystick.persistence.FireballSettings.parse(fireballConfiguration);
             var greatSwordSettings = greatSwordSettings();
             var frostShardConfiguration = frostShardConfiguration();
             var frostShardInitial = games.dmg.fantasystick.persistence.FrostShardSettings.parse(frostShardConfiguration);
@@ -329,7 +331,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 problem -> getLogger().log(Level.WARNING, "Combat reward failed for character " + problem.character(), problem.cause()));
             sessions.attachPvpDefeat(combatExperience::consumePvpDefeat);
             abilityRegistry = new games.dmg.fantasystick.ability.AbilityRegistry();
-            fireball = new games.dmg.fantasystick.ability.Fireball(fireballSettings);
+            fireballSettings = new games.dmg.fantasystick.persistence.FireballSettings(
+                getDataFolder().toPath(), fireballConfiguration);
+            fireball = new games.dmg.fantasystick.ability.Fireball(fireballInitial);
             frostShardSettings = new games.dmg.fantasystick.persistence.FrostShardSettings(
                 getDataFolder().toPath(), frostShardConfiguration);
             frostShard = new games.dmg.fantasystick.ability.FrostShard(frostShardInitial);
@@ -520,6 +524,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 quickstepSettings, quickstep, secondWindSettings, secondWind,
                 stoneSkinSettings, stoneSkin, shieldBashSettings, shieldBash, hexSettings, hex,
                 inspireSettings, inspire, abilityRegistry);
+            admin.attachFireball(fireballSettings, fireball);
             admin.attachMendingLight(mendingLightSettings, mendingLight);
             admin.attachPurify(purifySettings, purify);
             admin.attachGuardianBond(guardianBondSettings, guardianBond);
@@ -671,6 +676,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingCombatExperience = combatExperience; combatExperience = null;
         var closingAbilityEngine = abilityEngine; abilityEngine = null;
         var closingFireball = fireball; fireball = null;
+        var closingFireballSettings = fireballSettings; fireballSettings = null;
         var closingFrostShard = frostShard; frostShard = null;
         var closingFrostSettings = frostShardSettings; frostShardSettings = null;
         var closingLongbow = longbow; longbow = null;
@@ -741,6 +747,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingFeedbackCommand != null) cleanup("feedback command", closingFeedbackCommand::close);
         if (closingFeedbackPreferences != null) cleanup("feedback preferences", closingFeedbackPreferences::close);
         if (closingSettings != null) cleanup("configuration", closingSettings::close);
+        if (closingFireballSettings != null) cleanup("Fireball configuration", closingFireballSettings::close);
         if (closingFrostSettings != null) cleanup("Frost Shard configuration", closingFrostSettings::close);
         if (closingLongbowSettings != null) cleanup("Longbow configuration", closingLongbowSettings::close);
         if (closingQuickstepSettings != null) cleanup("Quickstep configuration", closingQuickstepSettings::close);
@@ -797,6 +804,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 : closingPartyEconomySettings.drained().toCompletableFuture(),
             closingSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingSettings.drained().toCompletableFuture(),
+            closingFireballSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingFireballSettings.drained().toCompletableFuture(),
             closingFrostSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingFrostSettings.drained().toCompletableFuture(),
             closingLongbowSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
@@ -972,18 +981,14 @@ public final class FantasyStickPlugin extends JavaPlugin {
         }
     }
 
-    private games.dmg.fantasystick.ability.Fireball.Settings fireballSettings() {
-        try {
-            var base = new java.math.BigInteger(getConfig().getString("fireball-base-damage", "6"));
-            var cooldown = java.time.Duration.ofSeconds(new java.math.BigInteger(
-                getConfig().getString("fireball-cooldown-seconds", "4")).longValueExact());
-            double range = new java.math.BigDecimal(getConfig().getString("fireball-range-blocks", "32")).doubleValue();
-            var lifetime = java.time.Duration.ofSeconds(new java.math.BigInteger(
-                getConfig().getString("fireball-lifetime-seconds", "5")).longValueExact());
-            return new games.dmg.fantasystick.ability.Fireball.Settings(base, cooldown, range, lifetime);
-        } catch (ArithmeticException | NumberFormatException invalid) {
-            throw new IllegalArgumentException("Fireball settings must use supported nonnegative numeric values", invalid);
+    private java.util.Map<String, String> fireballConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.FireballSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.FireballSettings.defaultValue(key)));
         }
+        games.dmg.fantasystick.persistence.FireballSettings.parse(values);
+        return java.util.Map.copyOf(values);
     }
 
     private java.util.Map<String, String> outOfCombatRecoveryConfiguration() {
@@ -1166,7 +1171,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.ability.GreatSword.Settings greatSwordSettings() {
         try {
             var base = new java.math.BigInteger(getConfig().getString("great-sword-base-damage", "7"));
-            var seconds = new java.math.BigDecimal(getConfig().getString("great-sword-recovery-seconds", "1.2"));
+            var seconds = new java.math.BigDecimal(getConfig().getString("great-sword-recovery-seconds", "0.75"));
             var recovery = java.time.Duration.ofNanos(seconds.movePointRight(9).toBigIntegerExact().longValueExact());
             return new games.dmg.fantasystick.ability.GreatSword.Settings(base, recovery);
         } catch (ArithmeticException | NumberFormatException invalid) {

src/main/java/games/dmg/fantasystick/ability/AbilityDefinition.java

@@ -13,9 +13,10 @@ import org.bukkit.Material;
 
 /** Immutable internal ability metadata and focused effect boundary; not an external add-on API. */
 public record AbilityDefinition(String id, String name, Material icon, List<String> lore, String instructions,
-        Map<Stat, BigInteger> requirements, BigInteger pointCost, Activation activation,
+        Map<Stat, BigInteger> requirements, BigInteger pointCost, Category category, Activation activation,
         ControlInput.Gesture gesture, Duration cooldown, Map<String, BigDecimal> parameters,
         TargetPolicy targetPolicy, AbilityEffect effect) {
+    public enum Category { ATK, BUF, HEAL }
     public enum Activation { IMMEDIATE, DELAYED, PROJECTILE, AREA, SELECTION }
     public enum TargetPolicy { SELF, HOSTILE, PROJECTILE_HOSTILE, ALLY, PARTY, AREA, SELECTION, EXCEPTIONAL_NONCOMBAT,
         EXCEPTIONAL_NONCOMBAT_SELECTION }
@@ -25,7 +26,7 @@ public record AbilityDefinition(String id, String name, Material icon, List<Stri
     public AbilityDefinition {
         Objects.requireNonNull(id); Objects.requireNonNull(name); Objects.requireNonNull(icon);
         Objects.requireNonNull(lore); Objects.requireNonNull(instructions); Objects.requireNonNull(requirements);
-        Objects.requireNonNull(pointCost); Objects.requireNonNull(activation); Objects.requireNonNull(gesture);
+        Objects.requireNonNull(pointCost); Objects.requireNonNull(category); Objects.requireNonNull(activation); Objects.requireNonNull(gesture);
         Objects.requireNonNull(cooldown); Objects.requireNonNull(parameters); Objects.requireNonNull(targetPolicy);
         Objects.requireNonNull(effect);
         lore = List.copyOf(lore); requirements = Map.copyOf(requirements); parameters = Map.copyOf(parameters);

src/main/java/games/dmg/fantasystick/ability/ChainLightning.java

@@ -72,7 +72,7 @@ public final class ChainLightning implements AbilityEffect, Listener, AutoClosea
                 "Each jump deals " + decimal(current.jumpMultiplier().movePointRight(2))
                     + "% of the previous defined damage within " + decimal(BigDecimal.valueOf(current.jumpRange())) + " blocks."),
             "Use while aiming at the first visible hostile within " + decimal(BigDecimal.valueOf(current.initialRange())) + " blocks.",
-            Map.of(Stat.INT, BigInteger.valueOf(20), Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.INT, BigInteger.valueOf(20), Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "initial-range", BigDecimal.valueOf(current.initialRange()).stripTrailingZeros(),

src/main/java/games/dmg/fantasystick/ability/Fireball.java

@@ -15,47 +15,50 @@ import org.bukkit.Material;
 import org.bukkit.Particle;
 import org.bukkit.damage.DamageSource;
 import org.bukkit.damage.DamageType;
+import org.bukkit.entity.AbstractArrow;
+import org.bukkit.entity.Arrow;
 import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Snowball;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.ProjectileHitEvent;
 import org.bukkit.util.Vector;
 
-/** Fireball's owned snowball projectile, direct custom damage and bounded cleanup adapter. */
+/** Fireball's owned arrow flight, direct custom damage and bounded cleanup adapter. */
 public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
-    private static final double SPEED_PER_TICK = 1.0;
-
-    public record Settings(BigInteger baseDamage, Duration cooldown, double range, Duration lifetime) {
+    public record Settings(BigInteger baseDamage, Duration cooldown, double range, Duration lifetime, double speedPerTick) {
         public Settings {
             Objects.requireNonNull(baseDamage); Objects.requireNonNull(cooldown); Objects.requireNonNull(lifetime);
             if (baseDamage.signum() < 0 || cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
                     || !Double.isFinite(range) || range <= 0 || range > 1024
-                    || lifetime.isZero() || lifetime.isNegative() || lifetime.compareTo(Duration.ofSeconds(60)) > 0) {
+                    || lifetime.isZero() || lifetime.isNegative() || lifetime.compareTo(Duration.ofSeconds(60)) > 0
+                    || !Double.isFinite(speedPerTick) || speedPerTick < 0.01 || speedPerTick > 64) {
                 throw new IllegalArgumentException("Invalid Fireball settings");
             }
         }
         public static Settings defaults() {
-            return new Settings(BigInteger.valueOf(6), Duration.ofSeconds(4), 32, Duration.ofSeconds(5));
+            return new Settings(BigInteger.valueOf(6), Duration.ofMillis(1200), 32, Duration.ofSeconds(5), 3);
         }
     }
 
-    private final Settings settings;
+    private volatile Settings settings;
     private final Map<UUID, State> projectiles = new HashMap<>();
     private State damaging;
     private boolean closed;
 
     private final class State implements AutoCloseable {
-        final Snowball projectile;
+        final Arrow projectile;
         final AbilityExecution execution;
         final Location origin;
         final BigInteger intelligence;
+        final Settings settings;
         LivingEntity target;
         boolean finished;
-        State(Snowball projectile, AbilityExecution execution, Location origin, BigInteger intelligence) {
-            this.projectile = projectile; this.execution = execution; this.origin = origin; this.intelligence = intelligence;
+        State(Arrow projectile, AbilityExecution execution, Location origin, BigInteger intelligence, Settings settings) {
+            this.projectile = projectile; this.execution = execution; this.origin = origin;
+            this.intelligence = intelligence; this.settings = settings;
         }
         @Override public void close() {
             if (finished) return;
@@ -66,16 +69,19 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
     }
 
     public Fireball(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
 
     public AbilityDefinition definition() {
+        var current = settings;
         return new AbilityDefinition("fireball", "Fireball", Material.SNOWBALL,
-            List.of("Launch a bounded fiery snowball.", "Deals " + settings.baseDamage() + " + INT modifier damage."),
+            List.of("Launch a bounded fiery arrow flight.", "Deals " + current.baseDamage() + " + INT modifier damage."),
             "Use the equipped snowball; a miss still spends the cooldown.",
-            Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE,
-            AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, settings.cooldown(),
-            Map.of("base-damage", new BigDecimal(settings.baseDamage()),
-                "range", BigDecimal.valueOf(settings.range()).stripTrailingZeros(),
-                "lifetime", BigDecimal.valueOf(settings.lifetime().toMillis(), 3).stripTrailingZeros()),
+            Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
+            AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("base-damage", new BigDecimal(current.baseDamage()),
+                "range", BigDecimal.valueOf(current.range()).stripTrailingZeros(),
+                "lifetime", seconds(current.lifetime()),
+                "projectile-speed", BigDecimal.valueOf(current.speedPerTick()).stripTrailingZeros()),
             AbilityDefinition.TargetPolicy.PROJECTILE_HOSTILE, this);
     }
 
@@ -95,21 +101,24 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
 
     @Override public void activate(AbilityExecution execution) {
         if (closed || !execution.stillCurrent()) return;
+        var current = settings;
         var player = execution.input().player();
         Location origin = player.getEyeLocation().clone();
         Vector direction = origin.getDirection();
         if (!Double.isFinite(direction.getX()) || !Double.isFinite(direction.getY()) || !Double.isFinite(direction.getZ())
                 || direction.lengthSquared() == 0) throw new IllegalStateException("Fireball direction is unavailable");
-        var projectile = player.launchProjectile(Snowball.class, direction.normalize().multiply(SPEED_PER_TICK));
+        var projectile = player.launchProjectile(Arrow.class, direction.normalize().multiply(current.speedPerTick()));
+        projectile.setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
+        projectile.setDamage(0); projectile.setKnockbackStrength(0); projectile.setPierceLevel(0); projectile.setCritical(false);
         projectile.setVisualFire(true);
-        var state = new State(projectile, execution, origin, execution.character().stats().get(Stat.INT));
+        var state = new State(projectile, execution, origin, execution.character().stats().get(Stat.INT), current);
         if (projectiles.putIfAbsent(projectile.getUniqueId(), state) != null) {
             projectile.remove(); throw new IllegalStateException("Duplicate Fireball projectile identity");
         }
         execution.own(state);
-        long rangeTicks = Math.max(1, (long) Math.ceil(settings.range() / SPEED_PER_TICK));
+        long rangeTicks = Math.max(1, (long) Math.ceil(current.range() / current.speedPerTick()));
         execution.later(Duration.ofMillis(Math.multiplyExact(rangeTicks, 50)), execution::finish);
-        execution.later(settings.lifetime(), execution::finish);
+        execution.later(current.lifetime(), execution::finish);
         player.getWorld().spawnParticle(Particle.FLAME, origin, 8, 0.15, 0.15, 0.15, 0.01);
     }
 
@@ -121,7 +130,7 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
             if (closed || event.isCancelled() || !state.execution.stillCurrent()
                     || !(event.getHitEntity() instanceof LivingEntity target) || !inRange(state, event.getEntity().getLocation())
                     || state.execution.eligible(List.of(target), 1).isEmpty()) return;
-            BigInteger amount = damage(settings.baseDamage(), state.intelligence);
+            BigInteger amount = damage(state.settings.baseDamage(), state.intelligence);
             double nativeDamage = amount.bitLength() > 1023 ? Double.MAX_VALUE : amount.doubleValue();
             var source = DamageSource.builder(DamageType.FIREBALL).withCausingEntity(state.execution.input().player())
                 .withDirectEntity(state.projectile).withDamageLocation(state.projectile.getLocation()).build();
@@ -137,7 +146,14 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
     private boolean inRange(State state, Location current) {
         return current.getWorld() != null && state.origin.getWorld() != null
             && current.getWorld().equals(state.origin.getWorld())
-            && current.distanceSquared(state.origin) <= settings.range() * settings.range();
+            && current.distanceSquared(state.origin) <= state.settings.range() * state.settings.range();
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void containNativeDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Arrow arrow)) return;
+        var state = projectiles.get(arrow.getUniqueId());
+        if (state != null && damaging != state) event.setCancelled(true);
     }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@@ -153,6 +169,10 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
         state.execution.report(AbilityReport.Type.DAMAGE, event.getEntity(), BigDecimal.valueOf(event.getFinalDamage()));
     }
 
+    private static BigDecimal seconds(Duration duration) {
+        return BigDecimal.valueOf(duration.getSeconds()).add(BigDecimal.valueOf(duration.getNano(), 9)).stripTrailingZeros();
+    }
+
     @Override public void close() {
         if (closed) return;
         closed = true;

src/main/java/games/dmg/fantasystick/ability/FrostNova.java

@@ -102,7 +102,7 @@ public final class FrostNova implements AbilityEffect, Listener, AutoCloseable {
                     + current.baseDamage() + " + INT modifier damage.",
                 "Applies Slowness " + level(current.slownessAmplifier()) + " for " + seconds(current.slownessDuration()) + " seconds."),
             "Use to affect exposed enemies; caster, party and ordinary players are excluded.",
-            Map.of(Stat.INT, BigInteger.valueOf(16), Stat.DEX, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.INT, BigInteger.valueOf(16), Stat.DEX, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),

src/main/java/games/dmg/fantasystick/ability/FrostShard.java

@@ -15,11 +15,13 @@ import org.bukkit.Material;
 import org.bukkit.Particle;
 import org.bukkit.damage.DamageSource;
 import org.bukkit.damage.DamageType;
+import org.bukkit.entity.AbstractArrow;
+import org.bukkit.entity.Arrow;
 import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Snowball;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.ProjectileHitEvent;
 import org.bukkit.potion.PotionEffect;
@@ -45,12 +47,12 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         }
         public static Settings defaults() {
             return new Settings(BigInteger.valueOf(4), Duration.ofSeconds(5), 32, Duration.ofSeconds(5),
-                1, 0, Duration.ofSeconds(2));
+                3, 0, Duration.ofSeconds(2));
         }
     }
 
     private final class State implements AutoCloseable {
-        final Snowball projectile;
+        final Arrow projectile;
         final AbilityExecution execution;
         final Location origin;
         final BigInteger intelligence;
@@ -58,7 +60,7 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         LivingEntity target;
         boolean accepted;
         boolean finished;
-        State(Snowball projectile, AbilityExecution execution, Location origin, BigInteger intelligence, Settings settings) {
+        State(Arrow projectile, AbilityExecution execution, Location origin, BigInteger intelligence, Settings settings) {
             this.projectile = projectile; this.execution = execution; this.origin = origin;
             this.intelligence = intelligence; this.settings = settings;
         }
@@ -112,7 +114,7 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
                 "Deals " + current.baseDamage() + " + INT modifier damage and Slowness "
                     + level(current.slownessAmplifier()) + " for " + seconds(current.slownessDuration()) + "s."),
             "Use the equipped shard; a miss still spends the cooldown.",
-            Map.of(Stat.INT, BigInteger.valueOf(12), Stat.WIS, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.INT, BigInteger.valueOf(12), Stat.WIS, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "range", BigDecimal.valueOf(current.range()).stripTrailingZeros(),
@@ -144,7 +146,9 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         Vector direction = origin.getDirection();
         if (!Double.isFinite(direction.getX()) || !Double.isFinite(direction.getY()) || !Double.isFinite(direction.getZ())
                 || direction.lengthSquared() == 0) throw new IllegalStateException("Frost Shard direction is unavailable");
-        var projectile = player.launchProjectile(Snowball.class, direction.normalize().multiply(current.speedPerTick()));
+        var projectile = player.launchProjectile(Arrow.class, direction.normalize().multiply(current.speedPerTick()));
+        projectile.setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
+        projectile.setDamage(0); projectile.setKnockbackStrength(0); projectile.setPierceLevel(0); projectile.setCritical(false);
         var state = new State(projectile, execution, origin, execution.character().stats().get(Stat.INT), current);
         if (projectiles.putIfAbsent(projectile.getUniqueId(), state) != null) {
             projectile.remove(); throw new IllegalStateException("Duplicate Frost Shard projectile identity");
@@ -160,6 +164,13 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         player.getWorld().spawnParticle(Particle.SNOWFLAKE, origin, 8, 0.15, 0.15, 0.15, 0.01);
     }
 
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void containNativeDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Arrow arrow)) return;
+        var state = projectiles.get(arrow.getUniqueId());
+        if (state != null && damaging != state) event.setCancelled(true);
+    }
+
     @EventHandler(priority = EventPriority.MONITOR)
     public void hit(ProjectileHitEvent event) {
         var state = projectiles.remove(event.getEntity().getUniqueId());

src/main/java/games/dmg/fantasystick/ability/GreatSword.java

@@ -27,7 +27,7 @@ public final class GreatSword implements AbilityEffect, Listener, AutoCloseable
                 throw new IllegalArgumentException("Invalid Great Sword settings");
             }
         }
-        public static Settings defaults() { return new Settings(BigInteger.valueOf(7), Duration.ofMillis(1200)); }
+        public static Settings defaults() { return new Settings(BigInteger.valueOf(7), Duration.ofMillis(750)); }
     }
 
     private static final class Attempt {
@@ -50,7 +50,7 @@ public final class GreatSword implements AbilityEffect, Listener, AutoCloseable
             List.of("Charge a contained melee strike.",
                 "Fully charged: " + settings.baseDamage() + " + STR modifier damage."),
             "Attack with the equipped sword; partial charge follows the native attack curve.",
-            Map.of(Stat.STR, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.STR, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.ATTACK, settings.recovery(),
             Map.of("base-damage", new BigDecimal(settings.baseDamage())),
             AbilityDefinition.TargetPolicy.HOSTILE, this);

src/main/java/games/dmg/fantasystick/ability/GuardianBond.java

@@ -130,7 +130,7 @@ public final class GuardianBond implements AbilityEffect, Listener, AutoCloseabl
             List.of("Redirect " + decimal(current.redirectPercent()) + "% of an aimed party ally's combat damage.",
                 "Range " + decimal(BigDecimal.valueOf(current.range())) + " blocks for " + seconds(current.duration()) + " seconds."),
             "Use on an aimed active party ally; one guardian and one bond per ally.",
-            Map.of(Stat.CON, BigInteger.valueOf(16), Stat.WIS, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.CON, BigInteger.valueOf(16), Stat.WIS, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("range", BigDecimal.valueOf(current.range()).stripTrailingZeros(),
                 "duration-seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),

src/main/java/games/dmg/fantasystick/ability/Hex.java

@@ -30,7 +30,7 @@ public final class Hex implements AbilityEffect,AutoCloseable{
     public AbilityDefinition definition(){var current=settings;return new AbilityDefinition("hex","Hex",Material.SPIDER_EYE,
         List.of("Reduce an aimed hostile's combat damage by "+current.reductionPercent().stripTrailingZeros().toPlainString()+"%.",
             "Range "+BigDecimal.valueOf(current.range()).stripTrailingZeros().toPlainString()+" blocks; lasts "+seconds(current.duration())+" seconds."),
-        "Use while aiming at the first visible hostile; there is no fallback target.",Map.of(Stat.CHR,BigInteger.valueOf(14),Stat.WIS,BigInteger.valueOf(12)),BigInteger.ONE,
+        "Use while aiming at the first visible hostile; there is no fallback target.",Map.of(Stat.CHR,BigInteger.valueOf(14),Stat.WIS,BigInteger.valueOf(12)),BigInteger.ONE,AbilityDefinition.Category.ATK,
         AbilityDefinition.Activation.DELAYED,ControlInput.Gesture.USE,current.cooldown(),Map.of("range",BigDecimal.valueOf(current.range()).stripTrailingZeros(),
             "duration-seconds",BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),"damage-reduction-percent",current.reductionPercent()),
         AbilityDefinition.TargetPolicy.HOSTILE,this);}

src/main/java/games/dmg/fantasystick/ability/Inspire.java

@@ -5,7 +5,7 @@ public final class Inspire implements AbilityEffect,AutoCloseable{
  public record Settings(BigInteger baseTemporaryHealth,Duration cooldown,double range,Duration duration){public Settings{Objects.requireNonNull(baseTemporaryHealth);Objects.requireNonNull(cooldown);Objects.requireNonNull(duration);if(baseTemporaryHealth.signum()<0||baseTemporaryHealth.compareTo(BigDecimal.valueOf(Double.MAX_VALUE).toBigInteger())>0||cooldown.isNegative()||cooldown.compareTo(Duration.ofDays(365))>0||!Double.isFinite(range)||range<=0||range>64||duration.isZero()||duration.isNegative()||duration.compareTo(Duration.ofDays(1))>0)throw new IllegalArgumentException("Invalid Inspire settings");}public static Settings defaults(){return new Settings(BigInteger.valueOf(4),Duration.ofSeconds(15),12,Duration.ofSeconds(6));}}
  private volatile Settings settings;private final TemporaryHealth temporaryHealth;private boolean closed;
  public Inspire(Settings settings,TemporaryHealth temporaryHealth){this.settings=Objects.requireNonNull(settings);this.temporaryHealth=Objects.requireNonNull(temporaryHealth);}public void configure(Settings settings){this.settings=Objects.requireNonNull(settings);}
- public AbilityDefinition definition(){var s=settings;return new AbilityDefinition("inspire","Inspire",Material.AMETHYST_SHARD,List.of("Grant "+s.baseTemporaryHealth()+" + CHR modifier temporary health for "+seconds(s.duration())+" seconds.","Range "+BigDecimal.valueOf(s.range()).stripTrailingZeros().toPlainString()+" blocks for an aimed fantasy player."),"Sneak+Use selects self; normal Use requires an aimed fantasy player.",Map.of(Stat.CHR,BigInteger.valueOf(12),Stat.WIS,BigInteger.TEN),BigInteger.ONE,AbilityDefinition.Activation.DELAYED,ControlInput.Gesture.USE,s.cooldown(),Map.of("base-temporary-health",new BigDecimal(s.baseTemporaryHealth()),"range",BigDecimal.valueOf(s.range()).stripTrailingZeros(),"duration-seconds",BigDecimal.valueOf(s.duration().toNanos()).movePointLeft(9)),AbilityDefinition.TargetPolicy.ALLY,this);}
+ public AbilityDefinition definition(){var s=settings;return new AbilityDefinition("inspire","Inspire",Material.AMETHYST_SHARD,List.of("Grant "+s.baseTemporaryHealth()+" + CHR modifier temporary health for "+seconds(s.duration())+" seconds.","Range "+BigDecimal.valueOf(s.range()).stripTrailingZeros().toPlainString()+" blocks for an aimed fantasy player."),"Sneak+Use selects self; normal Use requires an aimed fantasy player.",Map.of(Stat.CHR,BigInteger.valueOf(12),Stat.WIS,BigInteger.TEN),BigInteger.ONE,AbilityDefinition.Category.BUF,AbilityDefinition.Activation.DELAYED,ControlInput.Gesture.USE,s.cooldown(),Map.of("base-temporary-health",new BigDecimal(s.baseTemporaryHealth()),"range",BigDecimal.valueOf(s.range()).stripTrailingZeros(),"duration-seconds",BigDecimal.valueOf(s.duration().toNanos()).movePointLeft(9)),AbilityDefinition.TargetPolicy.ALLY,this);}
  @Override public boolean accepts(ControlInput input){if(closed||!(input.target() instanceof Player target))return false;if(input.player().isSneaking())return target==input.player();return target!=input.player()&&inRange(input.player(),target,settings.range());}
  public static BigInteger amount(BigInteger charisma){return amount(BigInteger.valueOf(4),charisma);}static BigInteger amount(BigInteger base,BigInteger charisma){Objects.requireNonNull(base);Objects.requireNonNull(charisma);if(base.signum()<0||charisma.signum()<0)throw new IllegalArgumentException("Invalid Inspire amount");var delta=charisma.subtract(BigInteger.TEN);var divided=delta.divideAndRemainder(BigInteger.TWO);var modifier=divided[0];if(delta.signum()<0&&divided[1].signum()!=0)modifier=modifier.subtract(BigInteger.ONE);return base.add(modifier);}
  @Override public void activate(AbilityExecution execution){if(closed||!execution.stillCurrent()||!(execution.input().target() instanceof Player target))return;var s=from(execution.definition());if(execution.input().player().isSneaking()?target!=execution.input().player():target==execution.input().player()||!inRange(execution.input().player(),target,s.range())){execution.finish();return;}var exact=amount(s.baseTemporaryHealth(),execution.character().stats().get(Stat.CHR));double nativeAmount=exact.bitLength()>1023?Double.MAX_VALUE:exact.doubleValue();if(!Double.isFinite(nativeAmount)||nativeAmount<=0){execution.finish();return;}execution.own(temporaryHealth.grant(execution,target,nativeAmount));execution.later(s.duration(),execution::finish);}

src/main/java/games/dmg/fantasystick/ability/Longbow.java

@@ -83,7 +83,7 @@ public final class Longbow implements AbilityEffect, Listener, AutoCloseable {
             List.of("Draw and release an ammunition-free owned arrow.",
                 "A full draw deals " + current.baseDamage() + " + DEX modifier damage."),
             "Draw by holding use; release after at least " + current.minimumDrawTicks() + " ticks.",
-            Map.of(Stat.DEX, BigInteger.valueOf(14)), BigInteger.ONE,
+            Map.of(Stat.DEX, BigInteger.valueOf(14)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.DRAW_RELEASE, current.recovery(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "minimum-draw-ticks", BigDecimal.valueOf(current.minimumDrawTicks()),

src/main/java/games/dmg/fantasystick/ability/MendingLight.java

@@ -70,7 +70,7 @@ public final class MendingLight implements AbilityEffect {
             List.of("Restore a party ally's missing fantasy health.",
                 "Heals " + current.baseHealing() + " + WIS modifier within " + decimal(current.range()) + " blocks."),
             "Use while aiming at an injured active party ally; self and full-health targets are refused.",
-            Map.of(Stat.WIS, BigInteger.valueOf(12), Stat.CHR, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.WIS, BigInteger.valueOf(12), Stat.CHR, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.HEAL,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-healing", new BigDecimal(current.baseHealing()),
                 "range", BigDecimal.valueOf(current.range()).stripTrailingZeros()),

src/main/java/games/dmg/fantasystick/ability/Meteor.java

@@ -59,7 +59,7 @@ public final class Meteor implements AbilityEffect, Listener, AutoCloseable {
     public void configure(Settings settings){this.settings=Objects.requireNonNull(settings);}
     public AbilityDefinition definition(){var current=settings;return new AbilityDefinition("meteor","Meteor",Material.FIRE_CHARGE,
         List.of("Mark visible ground within "+decimal(current.targetRange())+" blocks for a "+seconds(current.warning())+"-second warning.","Impact exposed enemies in a "+decimal(current.radius())+"-block area for "+current.baseDamage()+" + INT modifier damage."),
-        "Use while looking at a solid top surface; the warning is visible and the impact never changes terrain.",Map.of(Stat.INT,BigInteger.valueOf(26),Stat.WIS,BigInteger.valueOf(20),Stat.CON,BigInteger.valueOf(12)),BigInteger.ONE,
+        "Use while looking at a solid top surface; the warning is visible and the impact never changes terrain.",Map.of(Stat.INT,BigInteger.valueOf(26),Stat.WIS,BigInteger.valueOf(20),Stat.CON,BigInteger.valueOf(12)),BigInteger.ONE,AbilityDefinition.Category.ATK,
         AbilityDefinition.Activation.DELAYED,ControlInput.Gesture.USE,current.cooldown(),Map.of("base-damage",new BigDecimal(current.baseDamage()),"target-range",BigDecimal.valueOf(current.targetRange()).stripTrailingZeros(),"warning-seconds",nanos(current.warning()),"radius",BigDecimal.valueOf(current.radius()).stripTrailingZeros(),"vertical-range",BigDecimal.valueOf(current.verticalRange()).stripTrailingZeros()),AbilityDefinition.TargetPolicy.AREA,this);}
     public static BigInteger damage(BigInteger intelligence){return damage(BigInteger.valueOf(14),intelligence);}
     static BigInteger damage(BigInteger base,BigInteger intelligence){Objects.requireNonNull(base);Objects.requireNonNull(intelligence);if(base.signum()<0||intelligence.signum()<0)throw new IllegalArgumentException("Invalid Meteor damage input");var delta=intelligence.subtract(BigInteger.TEN);var divided=delta.divideAndRemainder(BigInteger.TWO);var modifier=divided[0];if(delta.signum()<0&&divided[1].signum()!=0)modifier=modifier.subtract(BigInteger.ONE);return base.add(modifier);}

src/main/java/games/dmg/fantasystick/ability/Purify.java

@@ -58,7 +58,7 @@ public final class Purify implements AbilityEffect {
             List.of("Remove Poison, Wither, Slowness and Weakness.",
                 "Aimed party-ally range: " + decimal(current.range()) + " blocks; beneficial effects remain."),
             "Sneak+Use cleanses self; normal Use requires an aimed active party ally.",
-            Map.of(Stat.WIS, BigInteger.valueOf(14), Stat.CHR, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.WIS, BigInteger.valueOf(14), Stat.CHR, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("range", BigDecimal.valueOf(current.range()).stripTrailingZeros()),
             AbilityDefinition.TargetPolicy.PARTY, this);

src/main/java/games/dmg/fantasystick/ability/Quickstep.java

@@ -80,7 +80,7 @@ public final class Quickstep implements AbilityEffect, Listener, AutoCloseable {
             List.of("Dash forward with native horizontal movement.",
                 "Travel up to " + decimal(current.distance()) + " blocks while obstacles remain authoritative."),
             "Use while grounded, on foot, and not flying or gliding.",
-            Map.of(Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("distance", BigDecimal.valueOf(current.distance()).stripTrailingZeros(),
                 "speed", BigDecimal.valueOf(current.speedPerTick()).stripTrailingZeros()),

src/main/java/games/dmg/fantasystick/ability/RallyingCry.java

@@ -175,7 +175,7 @@ public final class RallyingCry implements AbilityEffect, AutoCloseable {
                     + " and " + decimal(current.damageBonusPercent()) + "% combat damage.",
                 "A " + decimal(BigDecimal.valueOf(current.radius())) + "-block sphere lasting " + seconds(current.duration()) + " seconds."),
             "Use to rally yourself and nearby active party members; copies do not stack.",
-            Map.of(Stat.CHR, BigInteger.valueOf(16), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.CHR, BigInteger.valueOf(16), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),
                 "duration-seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),

src/main/java/games/dmg/fantasystick/ability/Revive.java

@@ -85,7 +85,7 @@ public final class Revive implements AbilityEffect, Listener, AutoCloseable {
             List.of("Let another player continue one fallen character.", "A valid cast spends the daily opportunity."),
             "Use the equipped shard while aiming at another player within 12 blocks.",
             Map.of(Stat.WIS, BigInteger.valueOf(30), Stat.CHR, BigInteger.valueOf(24), Stat.CON, BigInteger.valueOf(12)),
-            BigInteger.ONE, AbilityDefinition.Activation.SELECTION, ControlInput.Gesture.USE, Duration.ofHours(24),
+            BigInteger.ONE, AbilityDefinition.Category.HEAL, AbilityDefinition.Activation.SELECTION, ControlInput.Gesture.USE, Duration.ofHours(24),
             Map.of("range", BigDecimal.valueOf(12), "selection-time", BigDecimal.valueOf(300),
                 "death-age", BigDecimal.valueOf(86400)),
             AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT_SELECTION, this);

src/main/java/games/dmg/fantasystick/ability/Sanctuary.java

@@ -174,7 +174,7 @@ public final class Sanctuary implements AbilityEffect, AutoCloseable {
                 "Party members inside heal " + decimal(current.healingPerPulse()) + " each second and take "
                     + decimal(current.damageReductionPercent()) + "% less combat damage."),
             "Use to hold exposed ground; healing starts after one second and the area does not follow you.",
-            Map.of(Stat.WIS, BigInteger.valueOf(24), Stat.CHR, BigInteger.valueOf(20), Stat.CON, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.WIS, BigInteger.valueOf(24), Stat.CHR, BigInteger.valueOf(20), Stat.CON, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.HEAL,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),
                 "vertical-range", BigDecimal.valueOf(current.verticalRange()).stripTrailingZeros(),

src/main/java/games/dmg/fantasystick/ability/SecondWind.java

@@ -51,7 +51,7 @@ public final class SecondWind implements AbilityEffect {
             List.of("Restore missing fantasy health.",
                 "Heals " + current.baseHealing() + " + WIS modifier, capped at maximum health."),
             "Use while injured; full health refuses without spending cooldown.",
-            Map.of(Stat.CON, BigInteger.valueOf(12), Stat.WIS, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.CON, BigInteger.valueOf(12), Stat.WIS, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.HEAL,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-healing", new BigDecimal(current.baseHealing())),
             AbilityDefinition.TargetPolicy.SELF, this);

src/main/java/games/dmg/fantasystick/ability/ShieldBash.java

@@ -35,7 +35,7 @@ public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable
                     || minimumVerticalKnockback > 8) throw new IllegalArgumentException("Invalid Shield Bash settings");
         }
         public static Settings defaults() {
-            return new Settings(BigInteger.valueOf(4), Duration.ofSeconds(6), 3, 0.8, 0.35);
+            return new Settings(BigInteger.valueOf(4), Duration.ofSeconds(3), 3, 0.8, 0.35);
         }
     }
     private static final class Attempt {
@@ -61,7 +61,7 @@ public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable
             List.of("Strike within " + decimal(current.range()) + " blocks for " + current.baseDamage() + " + STR modifier damage.",
                 "Accepted damage adds knockback; this shield never enables ordinary blocking."),
             "Attack a visible hostile at short range.", Map.of(Stat.STR, BigInteger.valueOf(12), Stat.CON, BigInteger.valueOf(12)),
-            BigInteger.ONE, AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.ATTACK, current.cooldown(),
+            BigInteger.ONE, AbilityDefinition.Category.ATK, AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.ATTACK, current.cooldown(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()), "range", decimalValue(current.range()),
                 "horizontal-knockback", decimalValue(current.horizontalKnockback()),
                 "minimum-vertical-knockback", decimalValue(current.minimumVerticalKnockback())),

src/main/java/games/dmg/fantasystick/ability/StoneSkin.java

@@ -53,7 +53,7 @@ public final class StoneSkin implements AbilityEffect, AutoCloseable {
         return new AbilityDefinition("stone_skin", "Stone Skin", Material.BRICK,
             List.of("Reduce entity and projectile combat damage by " + decimal(current.reductionPercent()) + "%.",
                 "Lasts " + decimal(BigDecimal.valueOf(current.duration().toMillis()).movePointLeft(3)) + " seconds without stacking."),
-            "Use to protect yourself; environmental damage is unchanged.", Map.of(Stat.CON, BigInteger.valueOf(14)), BigInteger.ONE,
+            "Use to protect yourself; environmental damage is unchanged.", Map.of(Stat.CON, BigInteger.valueOf(14)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("duration-seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),
                 "damage-reduction-percent", current.reductionPercent()), AbilityDefinition.TargetPolicy.SELF, this);

src/main/java/games/dmg/fantasystick/ability/WarBanner.java

@@ -181,7 +181,7 @@ public final class WarBanner implements AbilityEffect, AutoCloseable {
                 "Party members in its " + decimal(current.radius()) + "-block area gain " + decimal(current.damageBonusPercent())
                     + "% combat damage and " + decimal(current.knockbackResistancePercent()) + "% knockback resistance."),
             "Use while looking at the solid top surface where the fixed banner should stand; copies do not stack.",
-            Map.of(Stat.STR, BigInteger.valueOf(22), Stat.CHR, BigInteger.valueOf(22), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.STR, BigInteger.valueOf(22), Stat.CHR, BigInteger.valueOf(22), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("placement-range", BigDecimal.valueOf(current.placementRange()).stripTrailingZeros(),
                 "radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),

src/main/java/games/dmg/fantasystick/book/CharacterBookController.java

@@ -142,7 +142,8 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         if (record.unspentPoints().signum() > 0 && start == 0) statViews.put(input.session().player(), statView);
 
         var definitions = abilities.definitions().stream()
-            .sorted(java.util.Comparator.comparing(games.dmg.fantasystick.ability.AbilityDefinition::name)
+            .sorted(java.util.Comparator.comparing(games.dmg.fantasystick.ability.AbilityDefinition::category)
+                .thenComparing(games.dmg.fantasystick.ability.AbilityDefinition::name)
                 .thenComparing(games.dmg.fantasystick.ability.AbilityDefinition::id))
             .toList();
         var passiveDefinitions = passives.definitions().stream()
@@ -158,7 +159,6 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
                 passiveDefinitions.stream().map(games.dmg.fantasystick.passive.PassiveDefinition::id)
                     .collect(java.util.stream.Collectors.toUnmodifiableSet()));
             if (!passiveDefinitions.isEmpty()) passiveViews.put(input.session().player(), passiveView);
-            var details = definitions.stream().map(definition -> abilityPages(record, definition, abilityView)).toList();
             var passiveNames = passiveDefinitions.stream().collect(java.util.stream.Collectors.toMap(
                 games.dmg.fantasystick.passive.PassiveDefinition::id,
                 games.dmg.fantasystick.passive.PassiveDefinition::name));
@@ -168,24 +168,33 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
                 games.dmg.fantasystick.ability.AbilityDefinition::id, ignored -> 1));
             var passivePlaceholderTargets = passiveDefinitions.stream().collect(java.util.stream.Collectors.toMap(
                 games.dmg.fantasystick.passive.PassiveDefinition::id, ignored -> 1));
+            var placeholderDetails = definitions.stream()
+                .map(definition -> abilityPages(record, definition, abilityView, 1)).toList();
             int activeCount = activePages(record, definitions, placeholderTargets).size();
             int passiveCount = passiveSlotPages(record, passiveDefinitions, passivePlaceholderTargets).size();
-            int indexCount = indexPages(definitions, placeholderTargets).size();
+            var placeholderIndex = indexPages(definitions, placeholderTargets);
+            int indexCount = placeholderIndex.pages().size();
             int passiveIndexCount = passiveIndexPages(passiveDefinitions, passivePlaceholderTargets).size();
+            int indexStart = pages.size() + activeCount + passiveCount;
+            var indexTargets = new java.util.HashMap<String, Integer>();
+            placeholderIndex.relativePageByAbility().forEach((id, page) -> indexTargets.put(id, indexStart + page + 1));
             var targets = new java.util.HashMap<String, Integer>();
             int target = pages.size() + activeCount + passiveCount + indexCount + passiveIndexCount + 1;
             for (int index = 0; index < definitions.size(); index++) {
                 targets.put(definitions.get(index).id(), target);
-                target += details.get(index).size();
+                target += placeholderDetails.get(index).size();
             }
             var passiveTargets = new java.util.HashMap<String, Integer>();
             for (int index = 0; index < passiveDefinitions.size(); index++) {
                 passiveTargets.put(passiveDefinitions.get(index).id(), target);
                 target += passiveDetails.get(index).size();
             }
+            var index = indexPages(definitions, targets);
+            var details = definitions.stream()
+                .map(definition -> abilityPages(record, definition, abilityView, indexTargets.get(definition.id()))).toList();
             pages.addAll(activePages(record, definitions, targets));
             pages.addAll(passiveSlotPages(record, passiveDefinitions, passiveTargets));
-            pages.addAll(indexPages(definitions, targets));
+            pages.addAll(index.pages());
             pages.addAll(passiveIndexPages(passiveDefinitions, passiveTargets));
             details.forEach(pages::addAll);
             passiveDetails.forEach(pages::addAll);
@@ -274,17 +283,27 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         return builder.pages();
     }
 
-    private static java.util.List<Component> indexPages(
+    private record AbilityIndex(java.util.List<Component> pages, Map<String, Integer> relativePageByAbility) {
+        private AbilityIndex { pages = java.util.List.copyOf(pages); relativePageByAbility = Map.copyOf(relativePageByAbility); }
+    }
+
+    private static AbilityIndex indexPages(
             java.util.List<games.dmg.fantasystick.ability.AbilityDefinition> definitions, Map<String, Integer> targets) {
         var pages = new java.util.ArrayList<Component>();
-        for (int start = 0; start < definitions.size(); start += 11) {
-            var builder = new PageBuilder(); builder.text("Ability index"); builder.blank();
-            for (var definition : definitions.subList(start, Math.min(start + 11, definitions.size()))) {
-                builder.link("", definition.name(), targets.get(definition.id()));
+        var relativePages = new java.util.HashMap<String, Integer>();
+        for (var category : games.dmg.fantasystick.ability.AbilityDefinition.Category.values()) {
+            var grouped = definitions.stream().filter(definition -> definition.category() == category).toList();
+            for (int start = 0; start < grouped.size(); start += 11) {
+                var builder = new PageBuilder(); builder.text("Ability index"); builder.text(category.name());
+                int relativePage = pages.size();
+                for (var definition : grouped.subList(start, Math.min(start + 11, grouped.size()))) {
+                    builder.link("", definition.name(), targets.get(definition.id()));
+                    relativePages.put(definition.id(), relativePage);
+                }
+                pages.addAll(builder.pages());
             }
-            pages.addAll(builder.pages());
         }
-        return java.util.List.copyOf(pages);
+        return new AbilityIndex(pages, relativePages);
     }
 
     private static java.util.List<Component> passiveIndexPages(
@@ -326,7 +345,7 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
     }
 
     private static java.util.List<Component> abilityPages(CharacterRecord record,
-            games.dmg.fantasystick.ability.AbilityDefinition definition, AbilityView view) {
+            games.dmg.fantasystick.ability.AbilityDefinition definition, AbilityView view, int indexPage) {
         String requirements = definition.requirements().isEmpty() ? "none" : definition.requirements().entrySet().stream()
             .sorted(Map.Entry.comparingByKey()).map(entry -> entry.getKey() + " " + entry.getValue())
             .collect(java.util.stream.Collectors.joining(", "));
@@ -339,6 +358,7 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
             : !points ? "Unavailable: points" : !slot ? "Unavailable: slots" : "Available";
         var builder = new PageBuilder();
         builder.text(definition.name());
+        builder.text(definition.category().name());
         builder.text(requirements);
         if (learned) builder.component(abilityButton("Unlearn", ABILITY_UNLEARN, view, definition.id()));
         else if (stats && points && slot) builder.component(abilityButton("Learn", ABILITY_UNLOCK, view, definition.id()));
@@ -351,6 +371,8 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
             .sorted(Map.Entry.comparingByKey()).map(entry -> entry.getKey() + "=" + entry.getValue())
             .collect(java.util.stream.Collectors.joining(", ")));
         builder.text(state);
+        builder.component(Component.text("[Back to index]", net.kyori.adventure.text.format.NamedTextColor.DARK_BLUE)
+            .clickEvent(net.kyori.adventure.text.event.ClickEvent.changePage(indexPage)));
         return builder.pages();
     }
 

src/main/java/games/dmg/fantasystick/persistence/FireballSettings.java

@@ -0,0 +1,171 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.Fireball;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Fireball settings; publication remains a server-thread caller decision. */
+public final class FireballSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE_DAMAGE = "fireball-base-damage";
+    public static final String COOLDOWN = "fireball-cooldown-seconds";
+    public static final String RANGE = "fireball-range-blocks";
+    public static final String LIFETIME = "fireball-lifetime-seconds";
+    public static final String SPEED = "fireball-projectile-speed-blocks-per-tick";
+    private static final List<String> KEYS = List.of(BASE_DAMAGE, COOLDOWN, LIFETIME, SPEED, RANGE);
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "6", COOLDOWN, "1.2", RANGE, "32",
+        LIFETIME, "5", SPEED, "3");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, Fireball.Settings settings, Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-fireball-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public FireballSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    FireballSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath(); this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy); effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public Fireball.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized boolean publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return false;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence(); return true;
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted); parse(preview);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues); next.put(key, accepted);
+                    var parsed = parse(next); save(key, accepted); persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Fireball configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            if (key.equals(BASE_DAMAGE)) return new java.math.BigInteger(raw).toString();
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static Fireball.Settings parse(Map<String, String> values) {
+        try {
+            return new Fireball.Settings(new java.math.BigInteger(values.get(BASE_DAMAGE)), seconds(values.get(COOLDOWN)),
+                finite(values.get(RANGE)), seconds(values.get(LIFETIME)), finite(values.get(SPEED)));
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Fireball settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        return Duration.ofNanos(new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact());
+    }
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Unsafe lock");
+        }
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/FrostShardSettings.java

@@ -36,7 +36,7 @@ public final class FrostShardSettings implements AutoCloseable {
     public static final String SLOWNESS = "frost-shard-slowness-duration-seconds";
     private static final List<String> KEYS = List.of(BASE_DAMAGE, COOLDOWN, LIFETIME, SPEED, RANGE, AMPLIFIER, SLOWNESS);
     private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "4", COOLDOWN, "5", RANGE, "32",
-        LIFETIME, "5", SPEED, "1", AMPLIFIER, "0", SLOWNESS, "2");
+        LIFETIME, "5", SPEED, "3", AMPLIFIER, "0", SLOWNESS, "2");
 
     @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
     public record Update(String key, String value, FrostShard.Settings settings,

src/main/java/games/dmg/fantasystick/persistence/OutOfCombatRecoverySettings.java

@@ -30,7 +30,7 @@ public final class OutOfCombatRecoverySettings implements AutoCloseable {
     public static final String INTERVAL = "out-of-combat-healing-interval-seconds";
     public static final String AMOUNT = "out-of-combat-healing-amount";
     private static final List<String> KEYS = List.of(DELAY, INTERVAL, AMOUNT);
-    private static final Map<String, String> DEFAULTS = Map.of(DELAY, "30", INTERVAL, "10", AMOUNT, "1");
+    private static final Map<String, String> DEFAULTS = Map.of(DELAY, "10", INTERVAL, "10", AMOUNT, "1");
     private static final int MAX_BYTES = 1_048_576;
     private static final long MAX_SECONDS = 31_536_000L;
 

src/main/java/games/dmg/fantasystick/persistence/ShieldBashSettings.java

@@ -33,7 +33,7 @@ public final class ShieldBashSettings implements AutoCloseable {
     public static final String HORIZONTAL = "shield-bash-horizontal-knockback";
     public static final String VERTICAL = "shield-bash-minimum-vertical-knockback";
     private static final List<String> KEYS = List.of(BASE_DAMAGE, COOLDOWN, RANGE, HORIZONTAL, VERTICAL);
-    private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "4", COOLDOWN, "6", RANGE, "3",
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "4", COOLDOWN, "3", RANGE, "3",
         HORIZONTAL, "0.8", VERTICAL, "0.35");
 
     @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }

src/main/java/games/dmg/fantasystick/session/EquipmentAdminCommand.java

@@ -22,6 +22,8 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private final Consumer<Failure> diagnostics;
     private volatile boolean closed;
     private games.dmg.fantasystick.persistence.AdventureSettings settings;
+    private games.dmg.fantasystick.persistence.FireballSettings fireballSettings;
+    private games.dmg.fantasystick.ability.Fireball fireball;
     private games.dmg.fantasystick.persistence.FrostShardSettings frostSettings;
     private games.dmg.fantasystick.ability.FrostShard frostShard;
     private games.dmg.fantasystick.ability.AbilityRegistry abilities;
@@ -367,6 +369,12 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         partyRegistrars=Objects.requireNonNull(directory); partyRegistrarController=Objects.requireNonNull(controller);
     }
 
+    public void attachFireball(games.dmg.fantasystick.persistence.FireballSettings settings,
+            games.dmg.fantasystick.ability.Fireball effect) {
+        if (closed || fireballSettings != null) throw new IllegalStateException("Fireball already attached or command closed");
+        fireballSettings = Objects.requireNonNull(settings); fireball = Objects.requireNonNull(effect);
+    }
+
     public void attachTrainingDummies(games.dmg.fantasystick.training.TrainingDummyDirectory directory,
             games.dmg.fantasystick.training.TrainingDummyController controller) {
         if (closed || trainingDummies != null) throw new IllegalStateException("Training dummies already attached or command closed");
@@ -748,6 +756,9 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         if (meteorSettings != null && games.dmg.fantasystick.persistence.MeteorSettings.keys().contains(args[1])) {
             meteorConfiguration(sender, args); return;
         }
+        if (fireballSettings != null && games.dmg.fantasystick.persistence.FireballSettings.keys().contains(args[1])) {
+            fireballConfiguration(sender, args); return;
+        }
         if (frostSettings == null || !games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
             configurationUsage(sender); return;
         }
@@ -782,6 +793,33 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         });
     }
 
+    private void fireballConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + fireballSettings.value(key) + " (applies to future Fireball casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.FireballSettings.Update> operation;
+        try { operation = fireballSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Fireball setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null && fireballSettings.publish(saved)) {
+                    fireball.configure(fireballSettings.settings()); abilities.replace(fireball.definition());
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Fireball casts; active projectiles and deadlines are unchanged."
+                    : "Fireball configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
     private void outOfCombatRecoveryConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
         if (args.length == 2) {
@@ -1353,6 +1391,7 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             keys.add(games.dmg.fantasystick.persistence.QuickerRegenerationSettings.KEY);
             keys.add(games.dmg.fantasystick.persistence.QuickerRegenerationIISettings.KEY);
             keys.add(games.dmg.fantasystick.persistence.HealthStealSettings.KEY);
+            keys.addAll(games.dmg.fantasystick.persistence.FireballSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.FrostShardSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.LongbowSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.QuickstepSettings.keys());
@@ -1405,6 +1444,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
                 return matching(current.equals(games.dmg.fantasystick.persistence.HealthStealSettings.DEFAULT)
                     ? List.of(current) : List.of(current, games.dmg.fantasystick.persistence.HealthStealSettings.DEFAULT), args[2]);
             }
+            if (fireballSettings != null && games.dmg.fantasystick.persistence.FireballSettings.keys().contains(args[1])) {
+                String current = fireballSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.FireballSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
             if (frostSettings != null && games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
                 String current = frostSettings.value(args[1]);
                 String defaults = games.dmg.fantasystick.persistence.FrostShardSettings.defaultValue(args[1]);

src/main/java/games/dmg/fantasystick/session/OutOfCombatRecovery.java

@@ -40,7 +40,7 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
             }
         }
         public static Settings defaults() {
-            return new Settings(Duration.ofSeconds(30), Duration.ofSeconds(10), BigInteger.ONE);
+            return new Settings(Duration.ofSeconds(10), Duration.ofSeconds(10), BigInteger.ONE);
         }
     }
 

src/main/resources/config.yml

@@ -33,7 +33,7 @@ sheet-resource-pack-sha1: ''
 
 # Active-session recovery after actual accepted damage has stopped.
 # Admin command: /fantasystick config <key> [value]
-out-of-combat-healing-delay-seconds: 30
+out-of-combat-healing-delay-seconds: 10
 out-of-combat-healing-interval-seconds: 10
 out-of-combat-healing-amount: 1
 quicker-regeneration-i-bonus-healing: 1
@@ -60,14 +60,16 @@ boss-xp: 100
 restricted-kill-spacing-blocks: 3
 
 # Fireball defaults from the reviewed starter catalogue.
+# Admin command: /fantasystick config <key> [value]
 fireball-base-damage: 6
-fireball-cooldown-seconds: 4
+fireball-cooldown-seconds: 1.2
 fireball-range-blocks: 32
 fireball-lifetime-seconds: 5
+fireball-projectile-speed-blocks-per-tick: 3
 
 # Great Sword defaults from the reviewed starter catalogue.
 great-sword-base-damage: 7
-great-sword-recovery-seconds: 1.2
+great-sword-recovery-seconds: 0.75
 
 # Frost Shard defaults from the reviewed remaining-development packet.
 # Admin command: /fantasystick config <key> [value]
@@ -75,7 +77,7 @@ frost-shard-base-damage: 4
 frost-shard-cooldown-seconds: 5
 frost-shard-range-blocks: 32
 frost-shard-lifetime-seconds: 5
-frost-shard-projectile-speed-blocks-per-tick: 1
+frost-shard-projectile-speed-blocks-per-tick: 3
 frost-shard-slowness-amplifier: 0
 frost-shard-slowness-duration-seconds: 2
 
@@ -109,7 +111,7 @@ stone-skin-damage-reduction-percent: 25
 # Shield Bash defaults from the reviewed remaining-development packet.
 # Admin command: /fantasystick config <key> [value]
 shield-bash-base-damage: 4
-shield-bash-cooldown-seconds: 6
+shield-bash-cooldown-seconds: 3
 shield-bash-range-blocks: 3
 shield-bash-horizontal-knockback: 0.8
 shield-bash-minimum-vertical-knockback: 0.35

src/nativeTest/java/games/dmg/fantasystick/AbilityEngineNativeTest.java

@@ -135,7 +135,7 @@ class AbilityEngineNativeTest {
             var registry = (AbilityRegistry) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
             var effects = new AtomicInteger();
             registry.register(new AbilityDefinition("test_focus", "Test Focus", Material.AMETHYST_SHARD,
-                List.of("A registered test effect"), "Use the equipped shard", Map.of(), BigInteger.ONE,
+                List.of("A registered test effect"), "Use the equipped shard", Map.of(), BigInteger.ONE, AbilityDefinition.Category.BUF,
                 AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, Duration.ofSeconds(4),
                 Map.of("range", BigDecimal.valueOf(12)), AbilityDefinition.TargetPolicy.SELF,
                 execution -> { assertTrue(execution.stillCurrent()); effects.incrementAndGet(); }));
@@ -206,7 +206,7 @@ class AbilityEngineNativeTest {
     private static AbilityDefinition definition(String id, AbilityDefinition.Activation activation,
             AbilityDefinition.TargetPolicy targetPolicy, games.dmg.fantasystick.ability.AbilityEffect effect) {
         return new AbilityDefinition(id, id, Material.AMETHYST_SHARD, List.of("Test definition"), "Use test input",
-            Map.of(), BigInteger.ONE, activation, ControlInput.Gesture.USE, Duration.ZERO,
+            Map.of(), BigInteger.ONE, AbilityDefinition.Category.ATK, activation, ControlInput.Gesture.USE, Duration.ZERO,
             Map.of(), targetPolicy, effect);
     }
 

src/nativeTest/java/games/dmg/fantasystick/AbilityRegistryNativeTest.java

@@ -36,16 +36,19 @@ class AbilityRegistryNativeTest {
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "UPPER", valid.requirements(), valid.parameters(), valid.cooldown())),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "", valid.requirements(), valid.parameters(), valid.cooldown())),
             () -> assertThrows(IllegalArgumentException.class, () -> new AbilityDefinition("x", " ", Material.STONE,
-                List.of("Lore"), "Use", Map.of(Stat.INT, BigInteger.TEN), BigInteger.ONE,
+                List.of("Lore"), "Use", Map.of(Stat.INT, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.ATK,
                 AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, Duration.ZERO,
                 Map.of(), AbilityDefinition.TargetPolicy.HOSTILE, ignored -> {})),
+            () -> assertThrows(NullPointerException.class, () -> new AbilityDefinition("category", "Category", Material.STONE,
+                List.of("Lore"), "Use", Map.of(), BigInteger.ONE, null, AbilityDefinition.Activation.IMMEDIATE,
+                ControlInput.Gesture.USE, Duration.ZERO, Map.of(), AbilityDefinition.TargetPolicy.SELF, ignored -> {})),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "low", Map.of(Stat.INT, BigInteger.valueOf(9)), Map.of(), Duration.ZERO)),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "negative", valid.requirements(), Map.of("range", BigDecimal.valueOf(-1)), Duration.ZERO)),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "infinite", valid.requirements(), Map.of("range", new BigDecimal("1E1000000")), Duration.ZERO)),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "cooldown", valid.requirements(), Map.of(), Duration.ofSeconds(-1))),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "long_cooldown", valid.requirements(), Map.of(), Duration.ofDays(366))),
             () -> assertThrows(IllegalArgumentException.class, () -> new AbilityDefinition("air", "Air", Material.AIR,
-                List.of("Lore"), "Use", Map.of(), BigInteger.ONE, AbilityDefinition.Activation.IMMEDIATE,
+                List.of("Lore"), "Use", Map.of(), BigInteger.ONE, AbilityDefinition.Category.ATK, AbilityDefinition.Activation.IMMEDIATE,
                 ControlInput.Gesture.USE, Duration.ZERO, Map.of(), AbilityDefinition.TargetPolicy.SELF, ignored -> {}))
         );
     }
@@ -68,7 +71,7 @@ class AbilityRegistryNativeTest {
             for (var policy : AbilityDefinition.TargetPolicy.values()) {
                 var base = definition("x");
                 assertDoesNotThrow(() -> new AbilityDefinition("a_" + activation.name().toLowerCase() + "_" + policy.name().toLowerCase(),
-                    base.name(), base.icon(), base.lore(), base.instructions(), base.requirements(), base.pointCost(), activation,
+                    base.name(), base.icon(), base.lore(), base.instructions(), base.requirements(), base.pointCost(), base.category(), activation,
                     base.gesture(), base.cooldown(), base.parameters(), policy, base.effect()));
             }
         }
@@ -76,7 +79,7 @@ class AbilityRegistryNativeTest {
 
     static AbilityDefinition definition(String id) {
         return new AbilityDefinition(id, "Test Bolt", Material.AMETHYST_SHARD, List.of("A focused test effect"),
-            "Use the equipped control", Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE,
+            "Use the equipped control", Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, Duration.ofSeconds(4),
             Map.of("range", BigDecimal.valueOf(12), "duration", BigDecimal.valueOf(5)),
             AbilityDefinition.TargetPolicy.HOSTILE, ignored -> {});
@@ -85,6 +88,6 @@ class AbilityRegistryNativeTest {
     private static AbilityDefinition copy(AbilityDefinition value, String id, Map<Stat, BigInteger> requirements,
                                           Map<String, BigDecimal> parameters, Duration cooldown) {
         return new AbilityDefinition(id, value.name(), value.icon(), value.lore(), value.instructions(), requirements,
-            value.pointCost(), value.activation(), value.gesture(), cooldown, parameters, value.targetPolicy(), value.effect());
+            value.pointCost(), value.category(), value.activation(), value.gesture(), cooldown, parameters, value.targetPolicy(), value.effect());
     }
 }

src/nativeTest/java/games/dmg/fantasystick/CharacterBookNativeTest.java

@@ -334,26 +334,60 @@ class CharacterBookNativeTest {
             assertTrue(pages.get(2).getString().contains("3: No Ability"));
             int index = firstPageStarting(pages, "Ability index");
             assertTrue(index > 2);
-            var indexedNames = new java.util.ArrayList<String>();
+            var categorized = new java.util.LinkedHashMap<String, java.util.List<String>>();
+            var indexPageByAbility = new java.util.HashMap<String, Integer>();
             int partyPage = firstPageStarting(pages, "Party");
             for (int page = index; page < pages.size() && pages.get(page).getString().startsWith("Ability index"); page++) {
-                for (String line : pages.get(page).getString().split("\\n")) if (!line.isBlank() && !line.equals("Ability index")) {
-                    indexedNames.add(line);
-                    var jump = changePage(pages.get(page), line);
-                    assertNotNull(jump, line);
+                var lines = pages.get(page).getString().split("\\n");
+                assertTrue(lines.length >= 2); String category = lines[1];
+                assertTrue(java.util.List.of("ATK", "BUF", "HEAL").contains(category));
+                var names = categorized.computeIfAbsent(category, ignored -> new java.util.ArrayList<>());
+                for (int line = 2; line < lines.length; line++) if (!lines[line].isBlank()) {
+                    names.add(lines[line]); indexPageByAbility.put(lines[line], page);
+                    var jump = changePage(pages.get(page), lines[line]);
+                    assertNotNull(jump, lines[line]);
                     assertTrue(jump.page() - 1 < partyPage, "Ability details must precede party controls");
                 }
             }
-            var sortedNames = indexedNames.stream().sorted().toList();
-            assertEquals(sortedNames, indexedNames);
-            assertEquals(20, indexedNames.size());
+            assertEquals(java.util.List.of("ATK", "BUF", "HEAL"), new java.util.ArrayList<>(categorized.keySet()));
+            assertEquals(java.util.List.of("Chain Lightning", "Fireball", "Frost Nova", "Frost Shard", "Great Sword",
+                "Hex", "Longbow", "Meteor", "Shield Bash"), categorized.get("ATK"));
+            assertEquals(java.util.List.of("Guardian Bond", "Inspire", "Purify", "Quickstep", "Rallying Cry",
+                "Stone Skin", "War Banner"), categorized.get("BUF"));
+            assertEquals(java.util.List.of("Mending Light", "Revive", "Sanctuary", "Second Wind"), categorized.get("HEAL"));
+            assertEquals(20, categorized.values().stream().mapToInt(java.util.List::size).sum());
+            var detailStartByAbility = new java.util.HashMap<String, Integer>();
+            for (var entry : indexPageByAbility.entrySet()) {
+                var jump = changePage(pages.get(entry.getValue()), entry.getKey()); assertNotNull(jump);
+                detailStartByAbility.put(entry.getKey(), jump.page() - 1);
+            }
+            int passiveIndex = firstPageStarting(pages, "Passive index");
+            int firstPassiveDetail = Integer.MAX_VALUE;
+            for (int page = passiveIndex; page < pages.size() && pages.get(page).getString().startsWith("Passive index"); page++) {
+                for (String line : pages.get(page).getString().split("\\n")) if (!line.isBlank() && !line.equals("Passive index")) {
+                    var jump = changePage(pages.get(page), line); if (jump != null) firstPassiveDetail = Math.min(firstPassiveDetail, jump.page() - 1);
+                }
+            }
+            for (var entry : indexPageByAbility.entrySet()) {
+                int detailPage = detailStartByAbility.get(entry.getKey());
+                assertTrue(pages.get(detailPage).getString().startsWith(entry.getKey() + "\n"));
+                assertTrue(pages.get(detailPage).getString().split("\\n")[1].matches("ATK|BUF|HEAL"));
+                int end = firstPassiveDetail;
+                for (int other : detailStartByAbility.values()) if (other > detailPage) end = Math.min(end, other);
+                var backPages = new java.util.ArrayList<Integer>();
+                for (int candidate = detailPage; candidate < end; candidate++)
+                    if (changePage(pages.get(candidate), "[Back to index]") != null) backPages.add(candidate);
+                assertEquals(java.util.List.of(end - 1), backPages, entry.getKey());
+                var back = changePage(pages.get(end - 1), "[Back to index]"); assertNotNull(back);
+                assertEquals(entry.getValue() + 1, back.page(), entry.getKey());
+            }
             var fireballJump = changePage(pages.get(index), "Fireball");
             assertNotNull(fireballJump);
             var detail = pages.get(fireballJump.page() - 1);
-            assertTrue(detail.getString().startsWith("Fireball\nINT 12\n[Learn]"), detail.getString());
+            assertTrue(detail.getString().startsWith("Fireball\nATK\nINT 12\n[Learn]"), detail.getString());
             assertFalse(text(a.books.getLast()).contains("Cost:"));
             assertFalse(text(a.books.getLast()).contains("Requires:"));
-            assertTrue(text(a.books.getLast()).contains("Shield Bash\nSTR 12, CON 12"));
+            assertTrue(text(a.books.getLast()).contains("Shield Bash\nATK\nSTR 12, CON 12"));
             assertFalse(detail.getString().contains("Icon:"));
             assertFalse(text(a.books.getLast()).contains("Assign ability"));
             assertFalse(text(a.books.getLast()).contains("[3]"));
@@ -366,7 +400,29 @@ class CharacterBookNativeTest {
             assertTrue(refreshed.get(2).getString().contains("3: Fireball"));
             var activeJump = changePage(refreshed.get(2), "Fireball");
             assertNotNull(activeJump);
-            assertTrue(refreshed.get(activeJump.page() - 1).getString().startsWith("Fireball\nINT 12\n[Unlearn]"));
+            assertTrue(refreshed.get(activeJump.page() - 1).getString().startsWith("Fireball\nATK\nINT 12\n[Unlearn]"));
+        }
+    }
+
+    @Test void mixedCategorySlotsAndUnknownIdsRemainUnrestrictedAndUnchanged() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+            var old = repository.load(a.core.record.id()).orElseThrow();
+            var mixed = new games.dmg.fantasystick.persistence.CharacterRecord(old.id(), old.name(), old.revision().add(java.math.BigInteger.ONE),
+                old.stats(), old.level(), old.experience(), old.unspentPoints(), old.health(),
+                java.util.Set.of("fireball", "quickstep", "second_wind", "unknown_saved"),
+                java.util.List.of("fireball", "quickstep", "second_wind", "unknown_saved", "", "", ""),
+                old.cooldowns(), old.restrictedKills(), false, null, null);
+            repository.replace(mixed, old.revision()); f.players.put(a.core.id, a.player); f.activate(a); PartyBookNativeTest.open(f, a);
+            var pages = nativePages(a); var active = pages.get(firstPageStarting(pages, "Active abilities"));
+            assertTrue(active.getString().contains("3: Fireball")); assertTrue(active.getString().contains("4: Quickstep"));
+            assertTrue(active.getString().contains("5: Second Wind")); assertTrue(active.getString().contains("6: unknown_saved"));
+            for (String ability : java.util.List.of("Fireball", "Quickstep", "Second Wind")) {
+                var jump = changePage(active, ability); assertNotNull(jump, ability);
+                assertTrue(pages.get(jump.page() - 1).getString().startsWith(ability + "\n"));
+            }
+            assertEquals(mixed, characters(f).find(mixed.id()).get(5, TimeUnit.SECONDS).orElseThrow());
         }
     }
 

src/nativeTest/java/games/dmg/fantasystick/FantasyStickLifecycleNativeTest.java

@@ -887,7 +887,9 @@ class FantasyStickLifecycleNativeTest {
         int scenario = 0;
         for (String row : List.of("fireball-base-damage: -1", "fireball-cooldown-seconds: -1",
                 "fireball-range-blocks: 0", "fireball-range-blocks: 1e1000000",
-                "fireball-lifetime-seconds: 0", "fireball-lifetime-seconds: 61")) {
+                "fireball-lifetime-seconds: 0", "fireball-lifetime-seconds: 61",
+                "fireball-projectile-speed-blocks-per-tick: 0",
+                "fireball-projectile-speed-blocks-per-tick: 65")) {
             var directory = data.resolve("invalid-fireball-" + scenario++); java.nio.file.Files.createDirectories(directory);
             String config = row + "\n"; java.nio.file.Files.writeString(directory.resolve("config.yml"), config);
             try (var f = new Fixture(directory)) {

src/nativeTest/java/games/dmg/fantasystick/FireballNativeTest.java

@@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.*;
 
 import java.math.BigInteger;
 import java.nio.file.Path;
+import java.util.UUID;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
@@ -21,6 +22,8 @@ class FireballNativeTest {
             PartyBookNativeTest.open(f, a);
             assertTrue(PartyBookNativeTest.text(a).contains("Fireball"));
             assertTrue(PartyBookNativeTest.text(a).contains("INT 12"));
+            assertTrue(PartyBookNativeTest.text(a).contains("Cooldown: 1.2s"));
+            assertTrue(PartyBookNativeTest.text(a).replaceAll("\\s+", "").contains("projectile-speed=3"));
             PartyBookNativeTest.click(f, a, PartyBookNativeTest.button(a, "[Learn]"));
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
             var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
@@ -41,7 +44,7 @@ class FireballNativeTest {
                 launches.incrementAndGet(); launchedVelocity.set(call.getArgument(1));
                 f.dispatcher.accept(new org.bukkit.event.entity.ProjectileLaunchEvent(projectile));
                 return projectile;
-            }).when(a.player).launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Snowball.class),
+            }).when(a.player).launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Arrow.class),
                 org.mockito.ArgumentMatchers.any(org.bukkit.util.Vector.class));
             a.core.inventory.getInventory().setSelectedSlot(2);
             var cast = new org.bukkit.event.player.PlayerInteractEvent(a.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
@@ -49,7 +52,10 @@ class FireballNativeTest {
             f.dispatcher.accept(cast); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
             assertEquals(org.bukkit.event.Event.Result.DENY, cast.useItemInHand()); assertEquals(1, launches.get());
             org.mockito.Mockito.verify(projectile).setVisualFire(true);
-            assertEquals(new org.bukkit.util.Vector(1, 0, 0), launchedVelocity.get());
+            org.mockito.Mockito.verify(projectile).setPickupStatus(org.bukkit.entity.AbstractArrow.PickupStatus.DISALLOWED);
+            org.mockito.Mockito.verify(projectile).setDamage(0); org.mockito.Mockito.verify(projectile).setCritical(false);
+            org.mockito.Mockito.verify(projectile).setPierceLevel(0); org.mockito.Mockito.verify(projectile).setKnockbackStrength(0);
+            assertEquals(new org.bukkit.util.Vector(3, 0, 0), launchedVelocity.get());
 
             var target = org.mockito.Mockito.mock(org.bukkit.entity.LivingEntity.class);
             org.mockito.Mockito.when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
@@ -58,6 +64,10 @@ class FireballNativeTest {
             org.mockito.Mockito.when(target.getHealth()).thenReturn(1d);
             org.mockito.Mockito.when(target.getAbsorptionAmount()).thenReturn(0d);
             org.mockito.Mockito.when(target.getLocation()).thenReturn(new org.bukkit.Location(a.world, 10, 65.6, 0));
+            var vanillaSource = org.mockito.Mockito.mock(org.bukkit.damage.DamageSource.class);
+            var vanilla = new org.bukkit.event.entity.EntityDamageByEntityEvent(projectile, target,
+                org.bukkit.event.entity.EntityDamageEvent.DamageCause.PROJECTILE, vanillaSource, 9);
+            f.dispatcher.accept(vanilla); assertTrue(vanilla.isCancelled(), "Owned arrow native damage is contained");
             var damages = new java.util.ArrayList<org.bukkit.event.entity.EntityDamageByEntityEvent>();
             org.mockito.Mockito.doAnswer(call -> {
                 var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
@@ -88,7 +98,7 @@ class FireballNativeTest {
             f.dispatcher.accept(new org.bukkit.event.player.PlayerInteractEvent(a.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
                 a.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND));
             PartyBookNativeTest.drain(f);
-            assertEquals(1, launches.get(), "The persisted four-second deadline refuses immediate reuse");
+            assertEquals(1, launches.get(), "The persisted 1.2-second deadline refuses immediate reuse");
             assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
             var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("fireball");
             assertTrue(deadline.isAfter(java.time.Instant.now()));
@@ -142,7 +152,7 @@ class FireballNativeTest {
             org.mockito.Mockito.doAnswer(call -> {
                 f.dispatcher.accept(new org.bukkit.event.entity.ProjectileLaunchEvent(projectile)); return projectile;
             }).when(a.player).launchProjectile(
-                org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Snowball.class), org.mockito.ArgumentMatchers.any(org.bukkit.util.Vector.class));
+                org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Arrow.class), org.mockito.ArgumentMatchers.any(org.bukkit.util.Vector.class));
             var events = new java.util.ArrayList<org.bukkit.event.entity.EntityDamageByEntityEvent>();
             org.mockito.Mockito.doAnswer(call -> {
                 var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
@@ -180,7 +190,7 @@ class FireballNativeTest {
             var eye = new org.bukkit.Location(a.world, 0, 65.6, 0); eye.setDirection(new org.bukkit.util.Vector(1, 0, 0));
             org.mockito.Mockito.doReturn(eye).when(a.player).getEyeLocation();
             org.mockito.Mockito.doAnswer(call -> { launches.incrementAndGet(); return projectile; }).when(a.player)
-                .launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Snowball.class),
+                .launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Arrow.class),
                     org.mockito.ArgumentMatchers.any(org.bukkit.util.Vector.class));
             cast(f, a);
             var cast = storage.find(a.core.record.id()).get().orElseThrow();
@@ -313,7 +323,8 @@ class FireballNativeTest {
 
     @Test void validatedConfiguredBalanceReachesTheRegisteredDefinition() throws Exception {
         java.nio.file.Files.writeString(data.resolve("config.yml"), "fireball-base-damage: 9\n"
-            + "fireball-cooldown-seconds: 2\nfireball-range-blocks: 40\nfireball-lifetime-seconds: 7\n");
+            + "fireball-cooldown-seconds: 2\nfireball-range-blocks: 40\nfireball-lifetime-seconds: 7\n"
+            + "fireball-projectile-speed-blocks-per-tick: 4\n");
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
             var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
@@ -323,7 +334,111 @@ class FireballNativeTest {
             assertEquals(new java.math.BigDecimal("9"), definition.parameters().get("base-damage"));
             assertEquals(0, new java.math.BigDecimal("40").compareTo(definition.parameters().get("range")));
             assertEquals(new java.math.BigDecimal("7"), definition.parameters().get("lifetime"));
+            assertEquals(new java.math.BigDecimal("4"), definition.parameters().get("projectile-speed"));
             assertTrue(String.join(" ", definition.lore()).contains("Deals 9"));
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = true;
+            assertEquals(java.util.List.of("fireball-projectile-speed-blocks-per-tick"), f.command.tabComplete(admin.port,
+                "fantasystick", new String[]{"config", "fireball-projectile-s"}));
+            assertEquals(java.util.List.of("3", "4"), f.command.tabComplete(admin.port, "fantasystick",
+                new String[]{"config", "fireball-projectile-speed-blocks-per-tick", ""}));
+            f.command.execute(admin.port, "fantasystick",
+                new String[]{"config", "fireball-projectile-speed-blocks-per-tick", "4.5"});
+            Runnable response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            var updated = registry.find("fireball").orElseThrow();
+            assertEquals(new java.math.BigDecimal("4.5"), updated.parameters().get("projectile-speed"));
+            assertTrue(java.nio.file.Files.readString(data.resolve("config.yml"))
+                .contains("fireball-projectile-speed-blocks-per-tick: '4.5'"));
+        }
+    }
+
+    @Test void liveSpeedUpdateAppliesOnlyToFutureCastsAndRetainsActiveArrow() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"), "fireball-cooldown-seconds: 0\n"
+            + "fireball-projectile-speed-blocks-per-tick: 2\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data); withFireball(data, a, 12);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            var eye = new org.bukkit.Location(a.world, 0, 65.6, 0); eye.setDirection(new org.bukkit.util.Vector(1, 0, 0));
+            org.mockito.Mockito.doReturn(eye).when(a.player).getEyeLocation();
+            var first = projectile(a, new org.bukkit.Location(a.world, 1, 65.6, 0));
+            var second = projectile(a, new org.bukkit.Location(a.world, 1, 65.6, 0));
+            var arrows = new java.util.ArrayDeque<>(java.util.List.of(first, second));
+            var velocities = new java.util.ArrayList<org.bukkit.util.Vector>();
+            org.mockito.Mockito.doAnswer(call -> {
+                velocities.add(call.getArgument(1)); return arrows.removeFirst();
+            }).when(a.player).launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Arrow.class),
+                org.mockito.ArgumentMatchers.any(org.bukkit.util.Vector.class));
+            cast(f, a); assertEquals(new org.bukkit.util.Vector(2, 0, 0), velocities.getFirst());
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = true;
+            f.command.execute(admin.port, "fantasystick",
+                new String[]{"config", "fireball-projectile-speed-blocks-per-tick", "4"});
+            Runnable response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            org.mockito.Mockito.verify(first, org.mockito.Mockito.never()).remove();
+            cast(f, a); assertEquals(java.util.List.of(new org.bukkit.util.Vector(2, 0, 0),
+                new org.bukkit.util.Vector(4, 0, 0)), velocities);
+        }
+    }
+
+    @Test void fractionalCooldownRefusesImmediatelyAndOneNanosecondBeforeButAcceptsExactBoundary() throws Exception {
+        var now = new java.util.concurrent.atomic.AtomicReference<>(java.time.Instant.parse("2026-09-21T20:00:00Z"));
+        java.time.Clock clock = new java.time.Clock() {
+            @Override public java.time.ZoneId getZone() { return java.time.ZoneOffset.UTC; }
+            @Override public java.time.Clock withZone(java.time.ZoneId zone) { return this; }
+            @Override public java.time.Instant instant() { return now.get(); }
+        };
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var created = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new java.util.EnumMap<>(created.stats()); stats.put(games.dmg.fantasystick.progression.Stat.INT, BigInteger.valueOf(12));
+        var initial = new games.dmg.fantasystick.persistence.CharacterRecord(created.id(), created.name(), created.revision(), stats,
+            created.level(), created.experience(), created.unspentPoints(), created.health(), java.util.Set.of("fireball"),
+            java.util.List.of("fireball", "", "", "", "", "", ""), created.cooldowns(), created.restrictedKills(), false, null, null);
+        try (var storage = new games.dmg.fantasystick.persistence.CharacterStorage(repository, clock)) {
+            storage.create(initial).get(5, java.util.concurrent.TimeUnit.SECONDS);
+            var current = new java.util.concurrent.atomic.AtomicReference<>(initial);
+            var sessions = org.mockito.Mockito.mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+            var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(UUID.randomUUID(), UUID.randomUUID(), initial.id());
+            org.mockito.Mockito.when(sessions.current(active)).thenReturn(true);
+            org.mockito.Mockito.when(sessions.currentRecord(active)).thenAnswer(ignored -> java.util.Optional.of(current.get()));
+            org.mockito.Mockito.when(sessions.acknowledgeProgress(org.mockito.ArgumentMatchers.eq(active),
+                org.mockito.ArgumentMatchers.any(), org.mockito.ArgumentMatchers.any())).thenAnswer(call -> {
+                    current.set(call.getArgument(2)); return true;
+                });
+            var player = org.mockito.Mockito.mock(org.bukkit.entity.Player.class); var world = org.mockito.Mockito.mock(org.bukkit.World.class);
+            var eye = new org.bukkit.Location(world, 0, 65.6, 0); eye.setDirection(new org.bukkit.util.Vector(1, 0, 0));
+            org.mockito.Mockito.when(player.getEyeLocation()).thenReturn(eye); org.mockito.Mockito.when(player.getWorld()).thenReturn(world);
+            var launches = new java.util.concurrent.atomic.AtomicInteger();
+            org.mockito.Mockito.when(player.launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Arrow.class),
+                org.mockito.ArgumentMatchers.any(org.bukkit.util.Vector.class))).thenAnswer(ignored -> {
+                    launches.incrementAndGet(); var arrow = org.mockito.Mockito.mock(org.bukkit.entity.Arrow.class);
+                    org.mockito.Mockito.when(arrow.getUniqueId()).thenReturn(UUID.randomUUID()); return arrow;
+                });
+            var fireball = new games.dmg.fantasystick.ability.Fireball(games.dmg.fantasystick.ability.Fireball.Settings.defaults());
+            var registry = new games.dmg.fantasystick.ability.AbilityRegistry(); registry.register(fireball.definition());
+            var parties = new games.dmg.fantasystick.party.PartyRoster(clock, ignored -> true);
+            var engine = new games.dmg.fantasystick.ability.AbilityEngine(registry, storage, sessions, parties, clock,
+                Runnable::run, (delay, action) -> () -> {}, ignored -> {}, failure -> fail(failure.toString()));
+            java.util.function.Consumer<Void> cast = ignored -> engine.accept(new games.dmg.fantasystick.session.ControlInput(player,
+                active, 2, "fireball", games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
+                games.dmg.fantasystick.session.ControlInput.Gesture.USE, null, 0, 0, () -> true));
+            cast.accept(null); await(launches, 1);
+            var deadline = now.get().plusMillis(1200); assertEquals(deadline, current.get().cooldowns().get("fireball"));
+            cast.accept(null); assertEquals(1, launches.get());
+            now.set(deadline.minusNanos(1)); cast.accept(null); assertEquals(1, launches.get());
+            now.set(deadline); cast.accept(null); await(launches, 2);
+            engine.close(); fireball.close(); parties.close();
+        }
+    }
+
+    @Test void retainedCooldownIsHonoredAndAbsentSpeedDefaultsWithoutRewritingConfiguration() throws Exception {
+        String retained = "fireball-cooldown-seconds: 4\n";
+        java.nio.file.Files.writeString(data.resolve("config.yml"), retained);
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var definition = ((games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry")).find("fireball").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(4), definition.cooldown());
+            assertEquals(new java.math.BigDecimal("3"), definition.parameters().get("projectile-speed"));
+            assertEquals(retained, java.nio.file.Files.readString(data.resolve("config.yml")));
         }
     }
 
@@ -358,7 +473,7 @@ class FireballNativeTest {
             games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
             games.dmg.fantasystick.session.ControlInput.Gesture.USE, null, 0, 0, () -> true));
         org.mockito.Mockito.verify(player, org.mockito.Mockito.never()).launchProjectile(
-            org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Snowball.class), org.mockito.ArgumentMatchers.any());
+            org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Arrow.class), org.mockito.ArgumentMatchers.any());
         org.mockito.Mockito.verify(sessions, org.mockito.Mockito.never()).acknowledgeProgress(
             org.mockito.ArgumentMatchers.any(), org.mockito.ArgumentMatchers.any(), org.mockito.ArgumentMatchers.any());
         assertEquals(1, failures.size());
@@ -383,11 +498,12 @@ class FireballNativeTest {
             assertEquals(java.util.Map.of(games.dmg.fantasystick.progression.Stat.INT, BigInteger.valueOf(12)),
                 fireball.requirements());
             assertEquals(BigInteger.ONE, fireball.pointCost());
-            assertEquals(java.time.Duration.ofSeconds(4), fireball.cooldown());
+            assertEquals(java.time.Duration.ofMillis(1200), fireball.cooldown());
             assertEquals(games.dmg.fantasystick.session.ControlInput.Gesture.USE, fireball.gesture());
             assertEquals(games.dmg.fantasystick.ability.AbilityDefinition.Activation.PROJECTILE, fireball.activation());
             assertEquals(new java.math.BigDecimal("32"), fireball.parameters().get("range"));
             assertEquals(new java.math.BigDecimal("5"), fireball.parameters().get("lifetime"));
+            assertEquals(new java.math.BigDecimal("3"), fireball.parameters().get("projectile-speed"));
             var unavailable = new FantasyStickLifecycleNativeTest.Actor(data);
             f.players.put(unavailable.core.id, unavailable.player); f.activate(unavailable);
             unavailable.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, unavailable);
@@ -397,6 +513,11 @@ class FireballNativeTest {
         }
     }
 
+    private static void await(java.util.concurrent.atomic.AtomicInteger value, int expected) throws Exception {
+        for (int attempt = 0; attempt < 500 && value.get() < expected; attempt++) Thread.sleep(10);
+        assertEquals(expected, value.get());
+    }
+
     private static void withFireball(Path data, FantasyStickLifecycleNativeTest.Actor actor, int intelligence) throws Exception {
         var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
         var old = repository.load(actor.core.record.id()).orElseThrow();
@@ -410,7 +531,7 @@ class FireballNativeTest {
 
     private static void prepareLaunches(FantasyStickLifecycleNativeTest.Fixture fixture,
                                         FantasyStickLifecycleNativeTest.Actor actor,
-                                        org.bukkit.entity.Snowball... projectiles) {
+                                        org.bukkit.entity.Arrow... projectiles) {
         var eye = new org.bukkit.Location(actor.world, 0, 65.6, 0);
         eye.setDirection(new org.bukkit.util.Vector(1, 0, 0));
         org.mockito.Mockito.doReturn(eye).when(actor.player).getEyeLocation();
@@ -419,7 +540,7 @@ class FireballNativeTest {
             var projectile = queue.removeFirst();
             fixture.dispatcher.accept(new org.bukkit.event.entity.ProjectileLaunchEvent(projectile));
             return projectile;
-        }).when(actor.player).launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Snowball.class),
+        }).when(actor.player).launchProjectile(org.mockito.ArgumentMatchers.eq(org.bukkit.entity.Arrow.class),
             org.mockito.ArgumentMatchers.any(org.bukkit.util.Vector.class));
     }
 
@@ -463,9 +584,9 @@ class FireballNativeTest {
         repository.replace(saved, old.revision());
     }
 
-    private static org.bukkit.entity.Snowball projectile(FantasyStickLifecycleNativeTest.Actor actor,
-                                                         org.bukkit.Location location) {
-        var projectile = org.mockito.Mockito.mock(org.bukkit.entity.Snowball.class);
+    private static org.bukkit.entity.Arrow projectile(FantasyStickLifecycleNativeTest.Actor actor,
+                                                      org.bukkit.Location location) {
+        var projectile = org.mockito.Mockito.mock(org.bukkit.entity.Arrow.class);
         org.mockito.Mockito.when(projectile.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
         org.mockito.Mockito.when(projectile.getShooter()).thenReturn(actor.player);
         org.mockito.Mockito.when(projectile.getLocation()).thenAnswer(ignored -> location.clone());

src/nativeTest/java/games/dmg/fantasystick/FrostShardNativeTest.java

@@ -25,6 +25,7 @@ class FrostShardNativeTest {
             String book = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
             assertTrue(book.contains("FrostShard"), book); assertTrue(book.contains("INT12"), book);
             assertTrue(book.contains("WIS10"), book); assertTrue(book.contains("SlownessI"), book);
+            assertTrue(book.contains("projectile-speed=3"), book);
             var learn = abilityButton(a, "[Learn]", "frost_shard");
             PartyBookNativeTest.click(f, a, learn); PartyBookNativeTest.click(f, a, learn);
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
@@ -41,17 +42,23 @@ class FrostShardNativeTest {
             eye.setDirection(new org.bukkit.util.Vector(1, 0, 0));
             doReturn(eye).when(a.player).getEyeLocation();
             var projectile = projectile(a, new org.bukkit.Location(a.world, 10, 65.6, 0));
+            var velocity = new java.util.concurrent.atomic.AtomicReference<org.bukkit.util.Vector>();
             doAnswer(call -> {
+                velocity.set(call.getArgument(1));
                 f.dispatcher.accept(new org.bukkit.event.entity.ProjectileLaunchEvent(projectile));
                 return projectile;
-            }).when(a.player).launchProjectile(eq(org.bukkit.entity.Snowball.class), any(org.bukkit.util.Vector.class));
+            }).when(a.player).launchProjectile(eq(org.bukkit.entity.Arrow.class), any(org.bukkit.util.Vector.class));
             a.core.inventory.getInventory().setSelectedSlot(2);
             var cast = new org.bukkit.event.player.PlayerInteractEvent(a.player,
                 org.bukkit.event.block.Action.RIGHT_CLICK_AIR, a.core.inventory.getItem(2), null,
                 org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND);
             f.dispatcher.accept(cast); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
             assertEquals(org.bukkit.event.Event.Result.DENY, cast.useItemInHand());
-            verify(a.player).launchProjectile(eq(org.bukkit.entity.Snowball.class), any(org.bukkit.util.Vector.class));
+            verify(a.player).launchProjectile(eq(org.bukkit.entity.Arrow.class), any(org.bukkit.util.Vector.class));
+            assertEquals(new org.bukkit.util.Vector(3, 0, 0), velocity.get());
+            verify(projectile).setPickupStatus(org.bukkit.entity.AbstractArrow.PickupStatus.DISALLOWED);
+            verify(projectile).setDamage(0); verify(projectile).setCritical(false);
+            verify(projectile).setPierceLevel(0); verify(projectile).setKnockbackStrength(0);
             var frost = FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "frostShard");
             assertEquals(1, ((java.util.Map<?, ?>) FantasyStickLifecycleNativeTest.Fixture.field(frost, "projectiles")).size());
 
@@ -60,6 +67,9 @@ class FrostShardNativeTest {
             when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
             when(target.getLocation()).thenReturn(new org.bukkit.Location(a.world, 10, 65.6, 0));
             when(target.addPotionEffect(any())).thenReturn(true);
+            var vanilla = new org.bukkit.event.entity.EntityDamageByEntityEvent(projectile, target,
+                org.bukkit.event.entity.EntityDamageEvent.DamageCause.PROJECTILE, mock(org.bukkit.damage.DamageSource.class), 9);
+            f.dispatcher.accept(vanilla); assertTrue(vanilla.isCancelled(), "Owned arrow native damage is contained");
             var damages = new java.util.ArrayList<org.bukkit.event.entity.EntityDamageByEntityEvent>();
             doAnswer(call -> {
                 var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
@@ -184,13 +194,13 @@ class FrostShardNativeTest {
             verify(projectile, atLeastOnce()).remove();
 
             learnAndAssign(f, a); cast(f, a);
-            verify(a.player, times(1)).launchProjectile(eq(org.bukkit.entity.Snowball.class), any(org.bukkit.util.Vector.class));
+            verify(a.player, times(1)).launchProjectile(eq(org.bukkit.entity.Arrow.class), any(org.bukkit.util.Vector.class));
             assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
             var sheet = a.core.inventory.getItemInOffHand().clone();
             a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
             var b = new FantasyStickLifecycleNativeTest.Actor(data); b.core.inventory.setItemInOffHand(sheet);
             f.players.put(b.core.id, b.player); f.activate(b); cast(f, b);
-            verify(b.player, never()).launchProjectile(eq(org.bukkit.entity.Snowball.class), any(org.bukkit.util.Vector.class));
+            verify(b.player, never()).launchProjectile(eq(org.bukkit.entity.Arrow.class), any(org.bukkit.util.Vector.class));
             assertTrue(b.messages.stream().anyMatch(message -> message.contains("ready in")));
             assertEquals(deadline, storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("frost_shard"));
         }
@@ -225,10 +235,22 @@ class FrostShardNativeTest {
         engine.accept(new games.dmg.fantasystick.session.ControlInput(player, active, 2, "frost_shard",
             games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
             games.dmg.fantasystick.session.ControlInput.Gesture.USE, null, 0, 0, () -> true));
-        verify(player, never()).launchProjectile(eq(org.bukkit.entity.Snowball.class), any(org.bukkit.util.Vector.class));
+        verify(player, never()).launchProjectile(eq(org.bukkit.entity.Arrow.class), any(org.bukkit.util.Vector.class));
         assertEquals(1, failures.size()); engine.close(); frost.close(); parties.close();
     }
 
+    @Test void retainedProjectileSpeedIsHonoredWithoutRewritingConfiguration() throws Exception {
+        String retained = "frost-shard-projectile-speed-blocks-per-tick: 1\n";
+        java.nio.file.Files.writeString(data.resolve("config.yml"), retained);
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var definition = ((games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry")).find("frost_shard").orElseThrow();
+            assertEquals(0, new java.math.BigDecimal("1").compareTo(definition.parameters().get("projectile-speed")));
+            assertEquals(retained, java.nio.file.Files.readString(data.resolve("config.yml")));
+        }
+    }
+
     @Test void configuredDefinitionAndFormulaPreserveReviewedFiniteUncappedScaling() throws Exception {
         java.nio.file.Files.writeString(data.resolve("config.yml"),
             "frost-shard-base-damage: 9\nfrost-shard-cooldown-seconds: 2.5\n"
@@ -286,7 +308,7 @@ class FrostShardNativeTest {
             doReturn(eye).when(a.player).getEyeLocation();
             var projectile = projectile(a, new org.bukkit.Location(a.world, 2, 65.6, 0));
             doAnswer(call -> { f.dispatcher.accept(new org.bukkit.event.entity.ProjectileLaunchEvent(projectile)); return projectile; })
-                .when(a.player).launchProjectile(eq(org.bukkit.entity.Snowball.class), any(org.bukkit.util.Vector.class));
+                .when(a.player).launchProjectile(eq(org.bukkit.entity.Arrow.class), any(org.bukkit.util.Vector.class));
             var target = mock(org.bukkit.entity.LivingEntity.class);
             when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
             when(target.getLocation()).thenReturn(new org.bukkit.Location(a.world, 2, 65.6, 0));
@@ -458,14 +480,14 @@ class FrostShardNativeTest {
 
     private static void prepareLaunches(FantasyStickLifecycleNativeTest.Fixture fixture,
                                         FantasyStickLifecycleNativeTest.Actor actor,
-                                        org.bukkit.entity.Snowball... projectiles) {
+                                        org.bukkit.entity.Arrow... projectiles) {
         var eye = new org.bukkit.Location(actor.world, 0, 65.6, 0);
         eye.setDirection(new org.bukkit.util.Vector(1, 0, 0)); doReturn(eye).when(actor.player).getEyeLocation();
         var queue = new java.util.ArrayDeque<>(java.util.List.of(projectiles));
         doAnswer(call -> {
             var projectile = queue.removeFirst(); fixture.dispatcher.accept(new org.bukkit.event.entity.ProjectileLaunchEvent(projectile));
             return projectile;
-        }).when(actor.player).launchProjectile(eq(org.bukkit.entity.Snowball.class), any(org.bukkit.util.Vector.class));
+        }).when(actor.player).launchProjectile(eq(org.bukkit.entity.Arrow.class), any(org.bukkit.util.Vector.class));
     }
 
     private static net.minecraft.network.chat.ClickEvent.Custom abilityButton(
@@ -518,9 +540,9 @@ class FrostShardNativeTest {
             old.learned(), old.loadout(), old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
     }
 
-    private static org.bukkit.entity.Snowball projectile(FantasyStickLifecycleNativeTest.Actor actor,
-                                                          org.bukkit.Location location) {
-        var projectile = mock(org.bukkit.entity.Snowball.class);
+    private static org.bukkit.entity.Arrow projectile(FantasyStickLifecycleNativeTest.Actor actor,
+                                                       org.bukkit.Location location) {
+        var projectile = mock(org.bukkit.entity.Arrow.class);
         when(projectile.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
         when(projectile.getShooter()).thenReturn(actor.player);
         when(projectile.getLocation()).thenAnswer(ignored -> location.clone());

src/nativeTest/java/games/dmg/fantasystick/GreatSwordNativeTest.java

@@ -26,7 +26,7 @@ class GreatSwordNativeTest {
             String book = PartyBookNativeTest.text(a);
             assertTrue(book.contains("Great Sword"));
             assertTrue(book.contains("STR 12"));
-            assertTrue(book.contains("1.2"));
+            assertTrue(book.contains("0.75"));
             var learn = abilityButton(a, "[Learn]", "great_sword");
             PartyBookNativeTest.click(f, a, learn); PartyBookNativeTest.click(f, a, learn);
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
@@ -68,8 +68,8 @@ class GreatSwordNativeTest {
             var saved = storage.find(a.core.record.id()).get().orElseThrow();
             var deadline = saved.cooldowns().get("great_sword");
             assertNotNull(deadline);
-            assertFalse(deadline.isBefore(before.plusMillis(1200)));
-            assertFalse(deadline.isAfter(java.time.Instant.now().plusMillis(1200)));
+            assertFalse(deadline.isBefore(before.plusMillis(750)));
+            assertFalse(deadline.isAfter(java.time.Instant.now().plusMillis(750)));
             f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(target, damages.getFirst().getDamageSource(),
                 new java.util.ArrayList<>(), 0));
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
@@ -259,6 +259,54 @@ class GreatSwordNativeTest {
         }
     }
 
+    @Test void fractionalRecoveryRefusesImmediatelyAndOneNanosecondBeforeButAcceptsExactBoundary() throws Exception {
+        var now = new java.util.concurrent.atomic.AtomicReference<>(java.time.Instant.parse("2026-09-21T20:00:00Z"));
+        java.time.Clock clock = new java.time.Clock() {
+            @Override public java.time.ZoneId getZone() { return java.time.ZoneOffset.UTC; }
+            @Override public java.time.Clock withZone(java.time.ZoneId zone) { return this; }
+            @Override public java.time.Instant instant() { return now.get(); }
+        };
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var created = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new java.util.EnumMap<>(created.stats()); stats.put(games.dmg.fantasystick.progression.Stat.STR, BigInteger.valueOf(12));
+        var initial = new games.dmg.fantasystick.persistence.CharacterRecord(created.id(), created.name(), created.revision(), stats,
+            created.level(), created.experience(), created.unspentPoints(), created.health(), java.util.Set.of("great_sword"),
+            java.util.List.of("great_sword", "", "", "", "", "", ""), created.cooldowns(), created.restrictedKills(), false, null, null);
+        try (var storage = new games.dmg.fantasystick.persistence.CharacterStorage(repository, clock)) {
+            storage.create(initial).get(5, java.util.concurrent.TimeUnit.SECONDS);
+            var current = new java.util.concurrent.atomic.AtomicReference<>(initial);
+            var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+            var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),
+                java.util.UUID.randomUUID(), initial.id());
+            when(sessions.current(active)).thenReturn(true);
+            when(sessions.currentRecord(active)).thenAnswer(ignored -> java.util.Optional.of(current.get()));
+            when(sessions.acknowledgeProgress(eq(active), any(), any())).thenAnswer(call -> {
+                current.set(call.getArgument(2)); return true;
+            });
+            var player = mock(org.bukkit.entity.Player.class); var target = mock(org.bukkit.entity.LivingEntity.class);
+            when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            var hits = new java.util.concurrent.atomic.AtomicInteger();
+            doAnswer(call -> { hits.incrementAndGet(); return null; }).when(target)
+                .damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            var sword = new games.dmg.fantasystick.ability.GreatSword(
+                games.dmg.fantasystick.ability.GreatSword.Settings.defaults());
+            var registry = new games.dmg.fantasystick.ability.AbilityRegistry(); registry.register(sword.definition());
+            var parties = new games.dmg.fantasystick.party.PartyRoster(clock, ignored -> true);
+            var engine = new games.dmg.fantasystick.ability.AbilityEngine(registry, storage, sessions, parties, clock,
+                Runnable::run, (delay, action) -> () -> {}, ignored -> {}, failure -> fail(failure.toString()));
+            Runnable cast = () -> engine.accept(new games.dmg.fantasystick.session.ControlInput(player, active, 2, "great_sword",
+                games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
+                games.dmg.fantasystick.session.ControlInput.Gesture.ATTACK, target, 0, 1, () -> true));
+            cast.run(); await(hits, 1);
+            var deadline = now.get().plusMillis(750); assertEquals(deadline, current.get().cooldowns().get("great_sword"));
+            cast.run(); assertEquals(1, hits.get());
+            now.set(deadline.minusNanos(1)); cast.run(); assertEquals(1, hits.get());
+            now.set(deadline); cast.run(); await(hits, 2);
+            engine.close(); sword.close(); parties.close();
+        }
+    }
+
     @Test void failedCooldownPersistenceDealsNoDamageOrFreeEffect() {
         var storage = mock(games.dmg.fantasystick.persistence.CharacterStorage.class);
         var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
@@ -312,6 +360,18 @@ class GreatSwordNativeTest {
         }
     }
 
+    @Test void retainedRecoveryIsHonoredWithoutRewritingConfiguration() throws Exception {
+        String retained = "great-sword-recovery-seconds: 1.2\n";
+        java.nio.file.Files.writeString(data.resolve("config.yml"), retained);
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var definition = ((games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry")).find("great_sword").orElseThrow();
+            assertEquals(java.time.Duration.ofMillis(1200), definition.cooldown());
+            assertEquals(retained, java.nio.file.Files.readString(data.resolve("config.yml")));
+        }
+    }
+
     @Test void configuredDefinitionAndChargeCurvePreserveExactUncappedScaling() throws Exception {
         java.nio.file.Files.writeString(data.resolve("config.yml"),
             "great-sword-base-damage: 9\ngreat-sword-recovery-seconds: 2.5\n");
@@ -389,6 +449,11 @@ class GreatSwordNativeTest {
             old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
     }
 
+    private static void await(java.util.concurrent.atomic.AtomicInteger value, int expected) throws Exception {
+        for (int attempt = 0; attempt < 500 && value.get() < expected; attempt++) Thread.sleep(10);
+        assertEquals(expected, value.get());
+    }
+
     private static void withStrength(Path data, FantasyStickLifecycleNativeTest.Actor actor, int strength) throws Exception {
         var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
         var old = repository.load(actor.core.record.id()).orElseThrow();

src/nativeTest/java/games/dmg/fantasystick/OutOfCombatRecoveryNativeTest.java

@@ -40,7 +40,7 @@ class OutOfCombatRecoveryNativeTest {
     @Test void exactDelayRepeatedIntervalsAndLargeClockJumpsPersistOnePulseBeforeNativePublication() {
         var f = new Direct();
         f.recovery.sweep();
-        f.clock.advance(Duration.ofSeconds(29)); f.recovery.sweep();
+        f.clock.advance(Duration.ofSeconds(9)); f.recovery.sweep();
         assertTrue(f.events.isEmpty());
 
         f.clock.advance(Duration.ofSeconds(1)); f.recovery.sweep();
@@ -72,12 +72,12 @@ class OutOfCombatRecoveryNativeTest {
 
     @Test void acceptedEnvironmentalAndDealtDamageResetWhileCancelledAndZeroAttemptsDoNot() {
         var f = new Direct(); f.recovery.sweep();
-        f.clock.advance(Duration.ofSeconds(29));
+        f.clock.advance(Duration.ofSeconds(9));
         f.recovery.acceptedDamage(damage(f.player, 2));
-        f.clock.advance(Duration.ofSeconds(29)); f.recovery.sweep(); assertTrue(f.events.isEmpty());
+        f.clock.advance(Duration.ofSeconds(9)); f.recovery.sweep(); assertTrue(f.events.isEmpty());
         f.clock.advance(Duration.ofSeconds(1)); f.recovery.sweep(); f.runNext(); assertEquals(5, f.health.get());
 
-        var noReset = new Direct(); noReset.recovery.sweep(); noReset.clock.advance(Duration.ofSeconds(29));
+        var noReset = new Direct(); noReset.recovery.sweep(); noReset.clock.advance(Duration.ofSeconds(9));
         var cancelled = damage(noReset.player, 2); cancelled.setCancelled(true); noReset.recovery.acceptedDamage(cancelled);
         noReset.recovery.acceptedDamage(damage(noReset.player, 0));
         noReset.clock.advance(Duration.ofSeconds(1)); noReset.recovery.sweep(); noReset.runNext();
@@ -85,58 +85,58 @@ class OutOfCombatRecoveryNativeTest {
 
         var dealt = new Direct();
         var target = mock(Player.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
-        dealt.recovery.sweep(); dealt.clock.advance(Duration.ofSeconds(29));
+        dealt.recovery.sweep(); dealt.clock.advance(Duration.ofSeconds(9));
         var source = DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
             .withCausingEntity(dealt.player).withDirectEntity(dealt.player).build();
         dealt.recovery.acceptedDamage(new EntityDamageByEntityEvent(dealt.player, target,
             EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 2));
-        dealt.clock.advance(Duration.ofSeconds(29)); dealt.recovery.sweep(); assertTrue(dealt.events.isEmpty());
+        dealt.clock.advance(Duration.ofSeconds(9)); dealt.recovery.sweep(); assertTrue(dealt.events.isEmpty());
         dealt.clock.advance(Duration.ofSeconds(1)); dealt.recovery.sweep(); dealt.runNext();
         assertEquals(5, dealt.health.get(), "Accepted outgoing damage starts a fresh delay for its source character");
     }
 
     @Test void cancellationFailureAndDamageDuringPersistenceNeverPublishOrCatchUp() {
         var cancelled = new Direct(); cancelled.veto = true; cancelled.recovery.sweep();
-        cancelled.clock.advance(Duration.ofSeconds(30)); cancelled.recovery.sweep();
+        cancelled.clock.advance(Duration.ofSeconds(10)); cancelled.recovery.sweep();
         assertEquals(1, cancelled.events.size()); assertTrue(cancelled.callbacks.isEmpty()); assertEquals(4, cancelled.health.get());
         cancelled.clock.advance(Duration.ofSeconds(9)); cancelled.recovery.sweep(); assertEquals(1, cancelled.events.size());
 
-        var failed = new Direct(); failed.automatic = false; failed.recovery.sweep(); failed.clock.advance(Duration.ofSeconds(30));
+        var failed = new Direct(); failed.automatic = false; failed.recovery.sweep(); failed.clock.advance(Duration.ofSeconds(10));
         failed.recovery.sweep(); assertNotNull(failed.pending);
         failed.pending.completeExceptionally(new java.io.IOException("simulated")); failed.runNext();
         assertEquals(4, failed.health.get());
         failed.clock.advance(Duration.ofSeconds(9)); failed.recovery.sweep();
         assertEquals(1, failed.events.size(), "Failed persistence does not immediately replay a missed pulse");
 
-        var stale = new Direct(); stale.automatic = false; stale.recovery.sweep(); stale.clock.advance(Duration.ofSeconds(30));
+        var stale = new Direct(); stale.automatic = false; stale.recovery.sweep(); stale.clock.advance(Duration.ofSeconds(10));
         stale.recovery.sweep();
         stale.recovery.acceptedDamage(damage(stale.player, 1));
         stale.pending.complete(Optional.of(stale.saved(BigDecimal.valueOf(5)))); stale.runNext();
         assertEquals(4, stale.health.get(), "Damage during the save invalidates native publication");
-        stale.clock.advance(Duration.ofSeconds(29)); stale.recovery.sweep(); assertEquals(1, stale.events.size());
+        stale.clock.advance(Duration.ofSeconds(9)); stale.recovery.sweep(); assertEquals(1, stale.events.size());
     }
 
     @Test void passiveBonusZeroCancellationAndFullHealthStayInTheBasePulseTransaction() {
         var zero = new Direct(); zero.recovery.attachBonusHealing(ignored -> BigInteger.ZERO);
-        zero.recovery.sweep(); zero.clock.advance(Duration.ofSeconds(30)); zero.recovery.sweep(); zero.runNext();
+        zero.recovery.sweep(); zero.clock.advance(Duration.ofSeconds(10)); zero.recovery.sweep(); zero.runNext();
         assertEquals(5, zero.health.get(), "A zero passive bonus leaves the base pulse unchanged");
 
         var cancelled = new Direct(); cancelled.recovery.attachBonusHealing(ignored -> BigInteger.valueOf(3)); cancelled.veto = true;
         var cancelledRevision = cancelled.record.get().revision();
-        cancelled.recovery.sweep(); cancelled.clock.advance(Duration.ofSeconds(30)); cancelled.recovery.sweep();
+        cancelled.recovery.sweep(); cancelled.clock.advance(Duration.ofSeconds(10)); cancelled.recovery.sweep();
         assertEquals(4, cancelled.events.getFirst().getAmount());
         assertEquals(4, cancelled.health.get()); assertEquals(cancelledRevision, cancelled.record.get().revision());
 
         var full = new Direct(); full.health.set(10d); full.record.set(full.saved(BigDecimal.TEN));
         full.recovery.attachBonusHealing(ignored -> BigInteger.valueOf(3)); var fullRevision = full.record.get().revision();
-        full.recovery.sweep(); full.clock.advance(Duration.ofSeconds(30)); full.recovery.sweep();
+        full.recovery.sweep(); full.clock.advance(Duration.ofSeconds(10)); full.recovery.sweep();
         assertTrue(full.events.isEmpty()); assertEquals(fullRevision, full.record.get().revision());
     }
 
     @Test void stackedRegenerationBonusProducesOneMaximumCappedNativeAndPersistedPulse() {
         var f = new Direct(); f.health.set(9d); f.record.set(f.saved(BigDecimal.valueOf(9)));
         f.recovery.attachBonusHealing(ignored -> BigInteger.valueOf(3));
-        f.recovery.sweep(); f.clock.advance(Duration.ofSeconds(30)); f.recovery.sweep();
+        f.recovery.sweep(); f.clock.advance(Duration.ofSeconds(10)); f.recovery.sweep();
         assertEquals(1, f.events.size()); assertEquals(1, f.events.getFirst().getAmount());
         f.runNext(); assertEquals(10, f.health.get()); assertEquals(0, BigDecimal.TEN.compareTo(f.record.get().health()));
     }
@@ -151,6 +151,21 @@ class OutOfCombatRecoveryNativeTest {
         assertEquals(5, f.health.get(), "The new delay evaluates from the retained activity timestamp");
     }
 
+    @Test void retainedThirtySecondDelayRemainsEffectiveWithoutRewritingConfiguration() throws Exception {
+        String retained = "out-of-combat-healing-delay-seconds: 30\n";
+        java.nio.file.Files.writeString(data.resolve("config.yml"), retained);
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var settings = (games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "outOfCombatRecoverySettings");
+            assertEquals("30", settings.value(games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings.DELAY));
+            assertEquals(retained, java.nio.file.Files.readString(data.resolve("config.yml")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            assertEquals(List.of("10", "30"), f.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "out-of-combat-healing-delay-seconds", ""}));
+        }
+    }
+
     @Test void packagedPluginConnectsZeroDelayRecoveryConfigurationAndRestart() throws Exception {
         java.nio.file.Files.writeString(data.resolve("config.yml"),
             "out-of-combat-healing-delay-seconds: 0\nout-of-combat-healing-interval-seconds: 10\nout-of-combat-healing-amount: 1\n");

src/nativeTest/java/games/dmg/fantasystick/ShieldBashNativeTest.java

@@ -32,7 +32,7 @@ class ShieldBashNativeTest {
             a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
             String book = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
             assertTrue(book.contains("ShieldBash")); assertTrue(book.contains("STR12")); assertTrue(book.contains("CON12"));
-            assertFalse(book.contains("Cost:")); assertTrue(book.contains("3")); assertTrue(book.contains("6s"));
+            assertFalse(book.contains("Cost:")); assertTrue(book.contains("3")); assertTrue(book.contains("3s"));
             PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "shield_bash"));
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
             var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
@@ -197,6 +197,71 @@ class ShieldBashNativeTest {
         }
     }
 
+    @Test void packagedCooldownRefusesImmediatelyAndOneNanosecondBeforeButAcceptsExactBoundary() throws Exception {
+        var now = new java.util.concurrent.atomic.AtomicReference<>(java.time.Instant.parse("2026-09-21T20:00:00Z"));
+        java.time.Clock clock = new java.time.Clock() {
+            @Override public java.time.ZoneId getZone() { return java.time.ZoneOffset.UTC; }
+            @Override public java.time.Clock withZone(java.time.ZoneId zone) { return this; }
+            @Override public java.time.Instant instant() { return now.get(); }
+        };
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var created = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(created.stats()); stats.put(Stat.STR, BigInteger.valueOf(12)); stats.put(Stat.CON, BigInteger.valueOf(12));
+        var initial = new CharacterRecord(created.id(), created.name(), created.revision(), stats, created.level(), created.experience(),
+            created.unspentPoints(), created.health(), java.util.Set.of("shield_bash"),
+            List.of("shield_bash", "", "", "", "", "", ""), created.cooldowns(), created.restrictedKills(), false, null, null);
+        try (var storage = new CharacterStorage(repository, clock)) {
+            storage.create(initial).get(5, java.util.concurrent.TimeUnit.SECONDS);
+            var current = new java.util.concurrent.atomic.AtomicReference<>(initial);
+            var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+            var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),
+                java.util.UUID.randomUUID(), initial.id());
+            when(sessions.current(active)).thenReturn(true);
+            when(sessions.currentRecord(active)).thenAnswer(ignored -> java.util.Optional.of(current.get()));
+            when(sessions.acknowledgeProgress(eq(active), any(), any())).thenAnswer(call -> {
+                current.set(call.getArgument(2)); return true;
+            });
+            var world = mock(org.bukkit.World.class); var player = mock(org.bukkit.entity.Player.class);
+            when(player.getUniqueId()).thenReturn(active.player()); doReturn(new Location(world, 0, 64, 0)).when(player).getLocation();
+            var target = mock(org.bukkit.entity.LivingEntity.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getLocation()).thenReturn(new Location(world, 2, 64, 0)); doReturn(true).when(player).hasLineOfSight(target);
+            var hits = new java.util.concurrent.atomic.AtomicInteger();
+            doAnswer(call -> { hits.incrementAndGet(); return null; }).when(target)
+                .damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            var bash = new games.dmg.fantasystick.ability.ShieldBash(
+                games.dmg.fantasystick.ability.ShieldBash.Settings.defaults(), ignored -> {});
+            var registry = new games.dmg.fantasystick.ability.AbilityRegistry(); registry.register(bash.definition());
+            var parties = new games.dmg.fantasystick.party.PartyRoster(clock, ignored -> true);
+            var engine = new games.dmg.fantasystick.ability.AbilityEngine(registry, storage, sessions, parties, clock,
+                Runnable::run, (delay, action) -> () -> {}, ignored -> {}, failure -> fail(failure.toString()));
+            Runnable cast = () -> engine.accept(new games.dmg.fantasystick.session.ControlInput(player, active, 2, "shield_bash",
+                games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
+                games.dmg.fantasystick.session.ControlInput.Gesture.ATTACK, target, 0, 1, () -> true));
+            cast.run(); await(hits, 1);
+            var deadline = now.get().plusSeconds(3); assertEquals(deadline, current.get().cooldowns().get("shield_bash"));
+            cast.run(); assertEquals(1, hits.get());
+            now.set(deadline.minusNanos(1)); cast.run(); assertEquals(1, hits.get());
+            now.set(deadline); cast.run(); await(hits, 2);
+            engine.close(); bash.close(); parties.close();
+        }
+    }
+
+    @Test void retainedSixSecondCooldownIsHonoredWithoutRewritingConfiguration() throws Exception {
+        String retained = "shield-bash-cooldown-seconds: 6\n";
+        java.nio.file.Files.writeString(data.resolve("config.yml"), retained);
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(java.time.Duration.ofSeconds(6), registry.find("shield_bash").orElseThrow().cooldown());
+            assertEquals(retained, java.nio.file.Files.readString(data.resolve("config.yml")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            assertEquals(List.of("3", "6"), f.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "shield-bash-cooldown-seconds", ""}));
+        }
+    }
+
     @Test void exactDamageFormulaSupportsFiniteUncappedStats() {
         assertEquals(BigInteger.valueOf(5), games.dmg.fantasystick.ability.ShieldBash.damage(BigInteger.valueOf(12)));
         assertEquals(BigInteger.valueOf(3), games.dmg.fantasystick.ability.ShieldBash.damage(BigInteger.valueOf(9)));
@@ -291,6 +356,11 @@ class ShieldBashNativeTest {
         }
     }
 
+    private static void await(java.util.concurrent.atomic.AtomicInteger value, int expected) throws Exception {
+        for (int attempt = 0; attempt < 500 && value.get() < expected; attempt++) Thread.sleep(10);
+        assertEquals(expected, value.get());
+    }
+
     private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
                                        FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
         actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);

src/test/java/games/dmg/fantasystick/DistributionTest.java

@@ -49,10 +49,10 @@ class DistributionTest {
                 "The delivered configuration must expose the reviewed 15-minute default");
             assertTrue(defaults.contains("adventure-mode: true"));
             assertTrue(defaults.contains("great-sword-base-damage: 7"));
-            assertTrue(defaults.contains("great-sword-recovery-seconds: 1.2"));
+            assertTrue(defaults.contains("great-sword-recovery-seconds: 0.75"));
             for (String setting : java.util.List.of("frost-shard-base-damage: 4",
                     "frost-shard-cooldown-seconds: 5", "frost-shard-range-blocks: 32",
-                    "frost-shard-lifetime-seconds: 5", "frost-shard-projectile-speed-blocks-per-tick: 1",
+                    "frost-shard-lifetime-seconds: 5", "frost-shard-projectile-speed-blocks-per-tick: 3",
                     "frost-shard-slowness-amplifier: 0", "frost-shard-slowness-duration-seconds: 2")) {
                 assertTrue(defaults.contains(setting), "Missing packaged Frost Shard default: " + setting);
             }
@@ -74,7 +74,7 @@ class DistributionTest {
                     "stone-skin-duration-seconds: 4", "stone-skin-damage-reduction-percent: 25")) {
                 assertTrue(defaults.contains(setting), "Missing packaged Stone Skin default: " + setting);
             }
-            for (String setting : java.util.List.of("shield-bash-base-damage: 4", "shield-bash-cooldown-seconds: 6",
+            for (String setting : java.util.List.of("shield-bash-base-damage: 4", "shield-bash-cooldown-seconds: 3",
                     "shield-bash-range-blocks: 3", "shield-bash-horizontal-knockback: 0.8",
                     "shield-bash-minimum-vertical-knockback: 0.35")) {
                 assertTrue(defaults.contains(setting), "Missing packaged Shield Bash default: " + setting);
@@ -104,7 +104,7 @@ class DistributionTest {
             }
             assertTrue(defaults.contains("sheet-resource-pack-url: ''"));
             assertTrue(defaults.contains("sheet-resource-pack-sha1: ''"));
-            for (String setting : java.util.List.of("out-of-combat-healing-delay-seconds: 30",
+            for (String setting : java.util.List.of("out-of-combat-healing-delay-seconds: 10",
                     "out-of-combat-healing-interval-seconds: 10", "out-of-combat-healing-amount: 1",
                     "quicker-regeneration-i-bonus-healing: 1", "quicker-regeneration-ii-bonus-healing: 2",
                     "health-steal-healing-per-kill: 1")) {

src/test/java/games/dmg/fantasystick/persistence/FireballSettingsTest.java

@@ -0,0 +1,72 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class FireballSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesAcceptedKeysWithoutLosingUnrelatedConfiguration() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "adventure-mode: true\nunrelated: retained\n");
+        try (var settings = new FireballSettings(data, defaults())) {
+            var damage = settings.set(FireballSettings.BASE_DAMAGE, "9").toCompletableFuture();
+            var speed = settings.set(FireballSettings.SPEED, "4.5").toCompletableFuture();
+            var savedDamage = damage.get(5, TimeUnit.SECONDS); var savedSpeed = speed.get(5, TimeUnit.SECONDS);
+            assertEquals(new java.math.BigInteger("6"), settings.settings().baseDamage());
+            settings.publish(savedSpeed); settings.publish(savedDamage);
+            assertEquals(new java.math.BigInteger("9"), settings.settings().baseDamage());
+            assertEquals(4.5, settings.settings().speedPerTick());
+            var saved = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals(Boolean.TRUE, saved.get("adventure-mode")); assertEquals("retained", saved.get("unrelated"));
+            assertEquals("9", String.valueOf(saved.get(FireballSettings.BASE_DAMAGE)));
+            assertEquals("4.5", String.valueOf(saved.get(FireballSettings.SPEED)));
+        }
+    }
+
+    @Test void defaultsAndValidationAcceptFractionalCooldownAndRejectUnsafeValues() {
+        assertEquals("1.2", FireballSettings.defaultValue(FireballSettings.COOLDOWN));
+        assertEquals("3", FireballSettings.defaultValue(FireballSettings.SPEED));
+        try (var settings = new FireballSettings(data, defaults())) {
+            assertEquals(java.time.Duration.ofMillis(1200), settings.settings().cooldown());
+            for (var entry : Map.of(FireballSettings.BASE_DAMAGE, "-1", FireballSettings.COOLDOWN, "31536001",
+                    FireballSettings.RANGE, "0", FireballSettings.LIFETIME, "0", FireballSettings.SPEED, "65").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(FireballSettings.BASE_DAMAGE, "1.5"));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(FireballSettings.COOLDOWN, "0.0000000001"));
+            assertFalse(Files.exists(data.resolve("config.yml")));
+        }
+    }
+
+    @Test void failedReplacementRetainsEffectiveAndFileStateAndCloseRejectsWrites() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "fireball-base-damage: 6\n");
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        var settings = new FireballSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated replacement failure");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        });
+        assertThrows(java.util.concurrent.ExecutionException.class, () ->
+            settings.set(FireballSettings.BASE_DAMAGE, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        assertEquals("6", settings.value(FireballSettings.BASE_DAMAGE));
+        var retry = settings.set(FireballSettings.BASE_DAMAGE, "9").toCompletableFuture().get(5, TimeUnit.SECONDS);
+        settings.publish(retry); assertEquals("9", settings.value(FireballSettings.BASE_DAMAGE));
+        settings.close();
+        assertThrows(java.util.concurrent.ExecutionException.class, () ->
+            settings.set(FireballSettings.BASE_DAMAGE, "10").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        settings.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var values = new LinkedHashMap<String, String>();
+        for (String key : FireballSettings.keys()) values.put(key, FireballSettings.defaultValue(key));
+        return values;
+    }
+}

src/test/java/games/dmg/fantasystick/persistence/FrostShardSettingsTest.java

@@ -36,7 +36,9 @@ class FrostShardSettingsTest {
     }
 
     @Test void rejectsMalformedAndOutOfRangeValuesBeforeQueueingOrChangingEffectiveState() {
+        assertEquals("3", FrostShardSettings.defaultValue(FrostShardSettings.SPEED));
         try (var settings = new FrostShardSettings(data, defaults())) {
+            assertEquals(3, settings.settings().speedPerTick());
             for (var entry : Map.of(
                     FrostShardSettings.BASE_DAMAGE, "-1",
                     FrostShardSettings.COOLDOWN, "31536001",

src/test/java/games/dmg/fantasystick/persistence/OutOfCombatRecoverySettingsTest.java

@@ -18,7 +18,7 @@ class OutOfCombatRecoverySettingsTest {
     @Test void parsesReviewedWholeNumberBoundaries() {
         var defaults = defaults();
         var parsed = OutOfCombatRecoverySettings.parse(defaults);
-        assertEquals(Duration.ofSeconds(30), parsed.delay());
+        assertEquals(Duration.ofSeconds(10), parsed.delay());
         assertEquals(Duration.ofSeconds(10), parsed.interval());
         assertEquals(java.math.BigInteger.ONE, parsed.amount());
 
@@ -52,7 +52,7 @@ class OutOfCombatRecoverySettingsTest {
             var delay = settings.set(OutOfCombatRecoverySettings.DELAY, "45").toCompletableFuture();
             var amount = settings.set(OutOfCombatRecoverySettings.AMOUNT, "3").toCompletableFuture();
             var d = delay.get(5, TimeUnit.SECONDS); var a = amount.get(5, TimeUnit.SECONDS);
-            assertEquals("30", settings.value(OutOfCombatRecoverySettings.DELAY));
+            assertEquals("10", settings.value(OutOfCombatRecoverySettings.DELAY));
             settings.publish(a); settings.publish(d);
             assertEquals("45", settings.value(OutOfCombatRecoverySettings.DELAY));
             assertEquals("3", settings.value(OutOfCombatRecoverySettings.AMOUNT));

src/test/java/games/dmg/fantasystick/persistence/ShieldBashSettingsTest.java

@@ -9,6 +9,10 @@ import org.junit.jupiter.api.io.TempDir;
 
 class ShieldBashSettingsTest {
     @TempDir Path data;
+    @Test void packagedDefaultCooldownIsThreeSeconds() {
+        assertEquals("3", ShieldBashSettings.defaultValue(ShieldBashSettings.COOLDOWN));
+        assertEquals(java.time.Duration.ofSeconds(3), ShieldBashSettings.parse(defaults()).cooldown());
+    }
     @Test void serializesConcurrentKeysPreservesUnrelatedAndPublishesAcknowledgedSnapshots() throws Exception {
         Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
         try (var settings = new ShieldBashSettings(data, defaults())) {