feat(recovery): shorten initial healing delay

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;
         }
@@ -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/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/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
@@ -77,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
 

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/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/test/java/games/dmg/fantasystick/DistributionTest.java

@@ -52,7 +52,7 @@ class DistributionTest {
             assertTrue(defaults.contains("great-sword-recovery-seconds: 1.2"));
             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);
             }
@@ -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/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));