feat(feedback): report accepted combat effects

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

@@ -51,6 +51,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private org.bukkit.scheduler.BukkitTask armorMenuPulse;
     private games.dmg.fantasystick.party.PartyCombat partyCombat;
     private EquipmentAdminCommand admin;
+    private games.dmg.fantasystick.persistence.PlayerFeedbackPreferences feedbackPreferences;
+    private games.dmg.fantasystick.session.FantasyFeedbackCommand feedbackCommand;
+    private games.dmg.fantasystick.presentation.CombatFeedback combatFeedback;
     private volatile Object lifetime;
     private CharacterPresentation presentation;
     private ProtocolPresentation protocolPresentation;
@@ -238,6 +241,13 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 problem -> getLogger().log(Level.WARNING, "Character craft " + problem.operation() + " for player "
                     + problem.player() + "; character records " + problem.characters(), problem.cause()));
             java.util.function.Consumer<Runnable> nextTick = task -> getServer().getScheduler().runTask(this, task);
+            try {
+                feedbackPreferences = new games.dmg.fantasystick.persistence.PlayerFeedbackPreferences(getDataFolder().toPath());
+            } catch (java.io.IOException invalidPreferences) {
+                throw new java.io.UncheckedIOException("Player feedback preferences could not be loaded", invalidPreferences);
+            }
+            feedbackCommand = new games.dmg.fantasystick.session.FantasyFeedbackCommand(feedbackPreferences, nextTick,
+                failure -> getLogger().log(Level.WARNING, "Player feedback preference failed", failure));
             java.util.function.Consumer<Throwable> presentationFailures = problem ->
                 getLogger().log(Level.WARNING, "Character presentation failed", problem);
             // This supplier belongs to one enable, never the mutable plugin field after re-enable.
@@ -285,6 +295,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 notice -> notifyPlayer(generation, notice), diagnostics, presentation, adventureSettings::enabled, gameModes);
             sessions.attachSwitchDelay(switchDelaySettings::delay);
             sessions.attachRoleplayDisabled(roleplaySettings::disabled);
+            combatFeedback = new games.dmg.fantasystick.presentation.CombatFeedback(feedbackPreferences, sessions);
             parties = new games.dmg.fantasystick.party.PartyRoster(characterParties, sessions, partySettings::maximum);
             characterParties.attachEnded(former -> nextTick.accept(() -> {
                 String message = "Party ended: " + former.displayName();
@@ -417,7 +428,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 Clock.systemUTC(), nextTick, event -> getServer().getPluginManager().callEvent(event),
                 games.dmg.fantasystick.session.NativeHealthLimit::read,
                 problem -> getLogger().log(Level.WARNING,
-                    "Out-of-combat recovery failed for character " + problem.character(), problem.cause()));
+                    "Out-of-combat recovery failed for character " + problem.character(), problem.cause()), combatFeedback);
             quickerRegenerationSettings = new games.dmg.fantasystick.persistence.QuickerRegenerationSettings(
                 getDataFolder().toPath(), quickerRegenerationInitial.bonus().toString());
             quickerRegeneration = new games.dmg.fantasystick.passive.QuickerRegenerationI(quickerRegenerationInitial);
@@ -428,7 +439,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 getDataFolder().toPath(), healthStealInitial.healing().toString());
             healthSteal = new games.dmg.fantasystick.passive.HealthSteal(healthStealInitial, characters, sessions, nextTick,
                 event -> getServer().getPluginManager().callEvent(event), games.dmg.fantasystick.session.NativeHealthLimit::read,
-                problem -> getLogger().log(Level.WARNING, "Health Steal failed for character " + problem.character(), problem.cause()));
+                problem -> getLogger().log(Level.WARNING, "Health Steal failed for character " + problem.character(), problem.cause()),
+                combatFeedback);
             speedI = new games.dmg.fantasystick.passive.SpeedI(sessions);
             lowLightVision = new games.dmg.fantasystick.passive.LowLightVision(sessions);
             passiveRegistry = new games.dmg.fantasystick.passive.PassiveRegistry();
@@ -458,7 +470,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 abilityScheduler::later, (size, title) -> getServer().createInventory(null, size, title),
                 problem -> getLogger().log(Level.WARNING, "Admin revival failed", problem));
             abilityEngine = new games.dmg.fantasystick.ability.AbilityEngine(abilityRegistry, characters, sessions, parties,
-                Clock.systemUTC(), nextTick, abilityScheduler, report -> { },
+                Clock.systemUTC(), nextTick, abilityScheduler, report -> { }, combatFeedback,
                 problem -> getLogger().log(Level.WARNING, "Ability engine failed for character " + problem.character()
                     + "; ability " + problem.ability(), problem.cause()));
             abilityEngine.install(this);
@@ -469,7 +481,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     var player = getServer().getPlayer(id);
                     return net.kyori.adventure.text.Component.text(name != null ? name : player == null ? id.toString() : player.getName());
                 }, abilityRegistry, abilityEngine, passiveRegistry, passiveEngine);
-            var localBasicAttack = new games.dmg.fantasystick.combat.BasicAttack(sessions);
+            var localBasicAttack = new games.dmg.fantasystick.combat.BasicAttack(sessions, Clock.systemUTC(), combatFeedback);
             basicAttack = localBasicAttack;
             sessionEvents = new EquipmentSessionEvents(sessions, nextTick, diagnostics, input -> {
                 books.accept(input);
@@ -537,6 +549,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
             var command = java.util.Objects.requireNonNull(getCommand("fantasystick"), "Missing packaged fantasystick command");
             command.setExecutor(admin);
             command.setTabCompleter(admin);
+            var playerFeedbackCommand = java.util.Objects.requireNonNull(getCommand("fantasyfeedback"),
+                "Missing packaged fantasyfeedback command");
+            playerFeedbackCommand.setExecutor(feedbackCommand);
+            playerFeedbackCommand.setTabCompleter(feedbackCommand);
             getServer().getPluginManager().registerEvents(crafting, this);
             getServer().getPluginManager().registerEvents(guard, this);
             getServer().getPluginManager().registerEvents(anvilNames, this);
@@ -612,6 +628,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingProtocol = protocolPresentation; protocolPresentation = null;
         var closingChat = chatNames; chatNames = null;
         var closingAdmin = admin; admin = null;
+        var closingFeedbackCommand = feedbackCommand; feedbackCommand = null;
+        var closingFeedbackPreferences = feedbackPreferences; feedbackPreferences = null;
+        combatFeedback = null;
         var closingEvents = sessionEvents; sessionEvents = null;
         var closingBooks = books; books = null;
         var closingPartyEvents = partyEvents; partyEvents = null;
@@ -708,6 +727,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingPresentation != null) cleanup("presentation", closingPresentation::close);
         if (closingProtocol != null) cleanup("protocol presentation", closingProtocol::close);
         if (closingAdmin != null) cleanup("admin command", closingAdmin::close);
+        if (closingFeedbackCommand != null) cleanup("feedback command", closingFeedbackCommand::close);
+        if (closingFeedbackPreferences != null) cleanup("feedback preferences", closingFeedbackPreferences::close);
         if (closingSettings != null) cleanup("configuration", closingSettings::close);
         if (closingFrostSettings != null) cleanup("Frost Shard configuration", closingFrostSettings::close);
         if (closingLongbowSettings != null) cleanup("Longbow configuration", closingLongbowSettings::close);
@@ -748,6 +769,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingQuickerRegenerationIISettings != null) cleanup("Quicker Regeneration II configuration", closingQuickerRegenerationIISettings::close);
         if (closingHealthStealSettings != null) cleanup("Health Steal configuration", closingHealthStealSettings::close);
         configurationDrain = java.util.concurrent.CompletableFuture.allOf(
+            closingFeedbackPreferences == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingFeedbackPreferences.drained().toCompletableFuture(),
             closingCharacterParties == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingCharacterParties.drained().toCompletableFuture(),
             closingPartyRegistrars == null ? java.util.concurrent.CompletableFuture.completedFuture(null)

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

@@ -39,6 +39,7 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
     private final Consumer<Runnable> nextTick;
     private final AbilityScheduler scheduler;
     private final Consumer<AbilityReport> reports;
+    private final AbilityFeedback feedback;
     private final Consumer<Failure> failures;
     private final Map<Key, Object> pending = new HashMap<>();
     private final Map<Key, Long> generations = new HashMap<>();
@@ -49,11 +50,18 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
     public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
             PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
             Consumer<AbilityReport> reports, Consumer<Failure> failures) {
+        this(registry, characters, sessions, parties, clock, nextTick, scheduler, reports,
+            (definition, input, type, target, amount) -> { }, failures);
+    }
+
+    public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
+            PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
+            Consumer<AbilityReport> reports, AbilityFeedback feedback, Consumer<Failure> failures) {
         this.registry = Objects.requireNonNull(registry); this.characters = Objects.requireNonNull(characters);
         this.sessions = Objects.requireNonNull(sessions); this.parties = Objects.requireNonNull(parties);
         this.clock = Objects.requireNonNull(clock); this.nextTick = Objects.requireNonNull(nextTick);
         this.scheduler = Objects.requireNonNull(scheduler); this.reports = Objects.requireNonNull(reports);
-        this.failures = Objects.requireNonNull(failures);
+        this.feedback = Objects.requireNonNull(feedback); this.failures = Objects.requireNonNull(failures);
     }
 
     public void install(org.bukkit.plugin.Plugin plugin) {
@@ -330,7 +338,10 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
             if (!stillCurrent() || definition.targetPolicy() == AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT
                     || definition.targetPolicy() == AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT_SELECTION
                     || target == null || !AbilityEngine.this.eligible(definition.targetPolicy(), input, target)) return;
-            reports.accept(new AbilityReport(type, key.character(), input.session().session(), target.getUniqueId(), amount, clock.instant()));
+            var report = new AbilityReport(type, key.character(), input.session().session(), target.getUniqueId(), amount, clock.instant());
+            reports.accept(report);
+            try { feedback.report(definition, input, type, target, report.amount()); }
+            catch (RuntimeException failure) { AbilityEngine.this.report(key.character(), key.ability(), failure); }
         }
         @Override public void finish() { close(); }
         @Override public void close() {

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

@@ -0,0 +1,11 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.session.ControlInput;
+import java.math.BigDecimal;
+import org.bukkit.entity.Entity;
+
+/** Presentation sink for an authoritative applied ability outcome. */
+@FunctionalInterface
+public interface AbilityFeedback {
+    void report(AbilityDefinition definition, ControlInput input, AbilityReport.Type type, Entity target, BigDecimal amount);
+}

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

@@ -142,8 +142,7 @@ public final class MendingLight implements AbilityEffect {
             target.player().setHealth(Math.min(maximum, current + restored));
             var amount = BigDecimal.valueOf(restored).stripTrailingZeros();
             supports.accept(new Support(execution.input().session().character(), target.active(), amount));
-            execution.input().player().sendMessage("Mending Light restored " + amount.toPlainString() + " health.");
-            target.player().sendMessage("Mending Light restored " + amount.toPlainString() + " health.");
+            execution.report(AbilityReport.Type.HEALING, target.player(), amount);
         } finally { execution.finish(); }
     }
 

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

@@ -81,12 +81,11 @@ public final class Purify implements AbilityEffect {
             if (target.player().getPotionEffect(type) == null) removed++;
         }
         if (removed == 0) return;
-        execution.input().player().sendMessage("Purify removed " + removed + " harmful effect" + (removed == 1 ? "." : "s."));
+        var amount = BigDecimal.valueOf(removed);
+        execution.report(AbilityReport.Type.CLEANSING, target.player(), amount);
         if (target.player() != execution.input().player()
                 && execution.stillCurrent() && current(execution.input(), target, configured.range())) {
-            var amount = BigDecimal.valueOf(removed);
             supports.accept(new Support(execution.input().session().character(), target.active(), amount));
-            target.player().sendMessage("Purify removed " + removed + " harmful effect" + (removed == 1 ? "." : "s."));
         }
     }
 

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

@@ -199,6 +199,8 @@ public final class Sanctuary implements AbilityEffect, AutoCloseable {
             double desired = Math.min(maximum, persisted.health().doubleValue()); double restored = Math.min(accepted, desired - current);
             if (!Double.isFinite(current) || !Double.isFinite(maximum) || !Double.isFinite(restored) || restored <= 0) return;
             target.player().setHealth(Math.min(maximum, current + restored));
+            state.execution.report(AbilityReport.Type.HEALING, target.player(),
+                BigDecimal.valueOf(restored).stripTrailingZeros());
             if (target.player() != state.source) supports.accept(new MendingLight.Support(
                 state.execution.input().session().character(), target.active(), BigDecimal.valueOf(restored).stripTrailingZeros()));
         } finally { completePending(state); }

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

@@ -105,8 +105,12 @@ public final class SecondWind implements AbilityEffect {
                         if (!sessions.acknowledgeProgress(execution.input().session(), expected, persisted)) {
                             player.sendMessage("Second Wind was saved, but the session changed; no native healing was applied."); return;
                         }
-                        double publish = Math.min(attribute.getValue(), Math.max(player.getHealth(), persisted.health().doubleValue()));
+                        double nativeBefore = player.getHealth();
+                        double publish = Math.min(attribute.getValue(), Math.max(nativeBefore, persisted.health().doubleValue()));
                         player.setHealth(publish);
+                        double restored = publish - nativeBefore;
+                        if (Double.isFinite(restored) && restored > 0) execution.report(AbilityReport.Type.HEALING,
+                            player, BigDecimal.valueOf(restored).stripTrailingZeros());
                     } finally { execution.finish(); }
                 });
             } catch (RuntimeException rejected) { execution.finish(); }

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

@@ -20,9 +20,9 @@ public final class TemporaryHealth implements Listener,AutoCloseable{
  private final Map<UUID,List<Grant>> grants=new HashMap<>();private long sequences;private boolean closed;
  public TemporaryHealth(EquipmentSessions sessions,PartyRoster parties,Consumer<Runnable> nextTick,Consumer<Support> supports){this.sessions=Objects.requireNonNull(sessions);this.parties=Objects.requireNonNull(parties);this.nextTick=Objects.requireNonNull(nextTick);this.supports=Objects.requireNonNull(supports);}
  public AutoCloseable grant(AbilityExecution execution,Player target,double amount){Objects.requireNonNull(execution);Objects.requireNonNull(target);if(closed||!Double.isFinite(amount)||amount<=0)throw new IllegalArgumentException("Invalid temporary health grant");double before=owned(target.getUniqueId());var grant=new Grant(execution,target,amount);grants.computeIfAbsent(target.getUniqueId(),ignored->new ArrayList<>()).add(grant);double after=owned(target.getUniqueId());addNative(target,Math.max(0,after-before));return grant;}
- @EventHandler(priority=EventPriority.MONITOR,ignoreCancelled=true)public void damage(EntityDamageEvent event){if(closed||!(event.getEntity() instanceof Player target))return;var owner=strongest(target.getUniqueId());if(owner==null||!owner.execution.stillCurrent())return;double before=target.getAbsorptionAmount(),owned=owned(target.getUniqueId());if(!Double.isFinite(before)||before<=0||owned<=0)return;Entity attacker=event instanceof EntityDamageByEntityEvent by?attacker(by):null;var aided=sessions.active(target.getUniqueId()).orElse(null);boolean qualifies=aided!=null&&sessions.current(aided)&&!aided.character().equals(owner.execution.input().session().character())&&sameParty(owner.execution.input().player(),target);UUID enemy=attacker==null?null:attacker.getUniqueId();long ownerSequence=owner.sequence;UUID source=owner.execution.input().session().character();
-  try{nextTick.accept(()->consume(target,before,owned,ownerSequence,source,qualifies?aided:null,enemy));}catch(RuntimeException ignored){}}
- private void consume(Player target,double before,double ownedBefore,long ownerSequence,UUID source,EquipmentSessions.Active aided,UUID enemy){if(closed)return;double after=target.getAbsorptionAmount();double consumed=Math.min(ownedBefore,Math.max(0,before-after));if(!Double.isFinite(consumed)||consumed<=0)return;var list=grants.get(target.getUniqueId());if(list==null)return;for(var grant:List.copyOf(list))grant.remaining=Math.max(0,grant.remaining-consumed);list.removeIf(g->g.closed||g.remaining<=1e-9);if(list.isEmpty())grants.remove(target.getUniqueId());if(aided!=null&&enemy!=null)supports.accept(new Support(enemy,source,aided,BigDecimal.valueOf(consumed).stripTrailingZeros()));}
+ @EventHandler(priority=EventPriority.MONITOR,ignoreCancelled=true)public void damage(EntityDamageEvent event){if(closed||!(event.getEntity() instanceof Player target))return;var owner=strongest(target.getUniqueId());if(owner==null||!owner.execution.stillCurrent())return;double before=target.getAbsorptionAmount(),owned=owned(target.getUniqueId());if(!Double.isFinite(before)||before<=0||owned<=0)return;Entity attacker=event instanceof EntityDamageByEntityEvent by?attacker(by):null;var aided=sessions.active(target.getUniqueId()).orElse(null);boolean qualifies=aided!=null&&sessions.current(aided)&&!aided.character().equals(owner.execution.input().session().character())&&sameParty(owner.execution.input().player(),target);UUID enemy=attacker==null?null:attacker.getUniqueId();
+  try{nextTick.accept(()->consume(target,before,owned,owner,qualifies?aided:null,enemy));}catch(RuntimeException ignored){}}
+ private void consume(Player target,double before,double ownedBefore,Grant owner,EquipmentSessions.Active aided,UUID enemy){if(closed)return;double after=target.getAbsorptionAmount();double consumed=Math.min(ownedBefore,Math.max(0,before-after));if(!Double.isFinite(consumed)||consumed<=0)return;var list=grants.get(target.getUniqueId());if(list==null)return;var amount=BigDecimal.valueOf(consumed).stripTrailingZeros();owner.execution.report(AbilityReport.Type.PREVENTION,target,amount);for(var grant:List.copyOf(list))grant.remaining=Math.max(0,grant.remaining-consumed);list.removeIf(g->g.closed||g.remaining<=1e-9);if(list.isEmpty())grants.remove(target.getUniqueId());if(aided!=null&&enemy!=null)supports.accept(new Support(enemy,owner.execution.input().session().character(),aided,amount));}
  private boolean sameParty(Player source,Player target){var a=parties.partyOf(source.getUniqueId()).orElse(null);var b=parties.partyOf(target.getUniqueId()).orElse(null);return a!=null&&b!=null&&a.id().equals(b.id());}
  private Grant strongest(UUID target){Grant result=null;var list=grants.get(target);if(list!=null)for(var grant:List.copyOf(list))if(!grant.closed&&grant.remaining>0&&grant.execution.stillCurrent()&&(result==null||grant.remaining>result.remaining||grant.remaining==result.remaining&&grant.sequence>result.sequence))result=grant;return result;}
  private double owned(UUID target){double result=0;var list=grants.get(target);if(list!=null)for(var grant:List.copyOf(list))if(!grant.closed&&grant.remaining>result)result=grant.remaining;return result;}

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

@@ -205,7 +205,7 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         return item;
     }
 
-    private Component gearPage(CharacterRecord record){return Component.text("Current gear\n\nHead: Cosmetic\nonly\nChestplate: "+tier(record.gear().chestplate())+"\nLeggings: "+tier(record.gear().leggings())+"\nBoots: "+tier(record.gear().boots()));}
+    private Component gearPage(CharacterRecord record){return Component.text("Gear\n\nHead: Cosmetic\nChestplate: "+tier(record.gear().chestplate())+"\nLeggings: "+tier(record.gear().leggings())+"\nBoots: "+tier(record.gear().boots()));}
     private static String tier(games.dmg.fantasystick.persistence.GearTier tier){String value=tier.name().toLowerCase(java.util.Locale.ROOT);return Character.toUpperCase(value.charAt(0))+value.substring(1);}
 
     private java.util.List<Component> overviewPages(CharacterRecord record, ControlInput input, StatView view) {

src/main/java/games/dmg/fantasystick/combat/BasicAttack.java

@@ -1,5 +1,7 @@
 package games.dmg.fantasystick.combat;
 
+import games.dmg.fantasystick.ability.AbilityReport;
+import games.dmg.fantasystick.presentation.CombatFeedback;
 import games.dmg.fantasystick.progression.Stat;
 import games.dmg.fantasystick.session.ControlInput;
 import games.dmg.fantasystick.session.EquipmentSessions;
@@ -23,6 +25,7 @@ public final class BasicAttack implements Consumer<ControlInput>, Listener, Auto
     private static final Duration CADENCE = Duration.ofSeconds(1);
     private final EquipmentSessions sessions;
     private final Clock clock;
+    private final CombatFeedback feedback;
     private final Map<UUID, Instant> readyAt = new HashMap<>();
     private Pending pending;
     private boolean closed;
@@ -38,12 +41,17 @@ public final class BasicAttack implements Consumer<ControlInput>, Listener, Auto
     }
 
     public BasicAttack(EquipmentSessions sessions) {
-        this(sessions, Clock.systemUTC());
+        this(sessions, Clock.systemUTC(), null);
     }
 
     public BasicAttack(EquipmentSessions sessions, Clock clock) {
+        this(sessions, clock, null);
+    }
+
+    public BasicAttack(EquipmentSessions sessions, Clock clock, CombatFeedback feedback) {
         this.sessions = Objects.requireNonNull(sessions);
         this.clock = Objects.requireNonNull(clock);
+        this.feedback = feedback;
     }
 
     @Override public void accept(ControlInput input) {
@@ -78,9 +86,11 @@ public final class BasicAttack implements Consumer<ControlInput>, Listener, Auto
     public void acceptedDamage(EntityDamageByEntityEvent event) {
         var attempt = pending;
         if (closed || attempt == null || event.isCancelled() || event.getFinalDamage() <= 0
-                || event.getDamager() != attempt.input.player() || event.getEntity() != attempt.target
+                || !Double.isFinite(event.getFinalDamage()) || event.getDamager() != attempt.input.player() || event.getEntity() != attempt.target
                 || !attempt.input.stillCurrent() || !sessions.current(attempt.input.session())) return;
         attempt.accepted = true;
+        if (feedback != null) feedback.report("Basic Attack", attempt.input.player(), AbilityReport.Type.DAMAGE,
+            event.getEntity(), java.math.BigDecimal.valueOf(event.getFinalDamage()).stripTrailingZeros());
     }
 
     @Override public void close() {

src/main/java/games/dmg/fantasystick/items/TailBooks.java

@@ -41,7 +41,7 @@ public final class TailBooks {
             .append("\nCoins: ").append(character.coins());
         for (Stat stat : Stat.values()) summary.append('\n').append(stat).append(": ").append(character.stats().get(stat));
         pages.addAll(BookPagination.pages(summary.toString()));
-        pages.addAll(BookPagination.pages("Current gear\nHead: Cosmetic only\nChestplate: "+tier(character.gear().chestplate())+"\nLeggings: "+tier(character.gear().leggings())+"\nBoots: "+tier(character.gear().boots())));
+        pages.addAll(BookPagination.pages("Gear\nHead: Cosmetic\nChestplate: "+tier(character.gear().chestplate())+"\nLeggings: "+tier(character.gear().leggings())+"\nBoots: "+tier(character.gear().boots())));
         if (character.learned().isEmpty()) pages.addAll(BookPagination.pages("Abilities: None"));
         character.learned().stream().sorted().forEach(ability -> {
             var slots = new ArrayList<String>();

src/main/java/games/dmg/fantasystick/passive/HealthSteal.java

@@ -1,6 +1,8 @@
 package games.dmg.fantasystick.passive;
 
+import games.dmg.fantasystick.ability.AbilityReport;
 import games.dmg.fantasystick.party.CombatSources;
+import games.dmg.fantasystick.presentation.CombatFeedback;
 import games.dmg.fantasystick.persistence.CharacterRecord;
 import games.dmg.fantasystick.persistence.CharacterStorage;
 import games.dmg.fantasystick.progression.Stat;
@@ -53,6 +55,7 @@ public final class HealthSteal implements Listener, AutoCloseable {
     private final Consumer<EntityRegainHealthEvent> healingEvents;
     private final Supplier<BigDecimal> nativeLimit;
     private final Consumer<Failure> failures;
+    private final CombatFeedback feedback;
     private final CombatSources sources;
     private final Map<UUID, Candidate> lethal = new java.util.HashMap<>();
     private final Set<PlayerDeathEvent> fantasyDefeats = Collections.newSetFromMap(new IdentityHashMap<>());
@@ -65,10 +68,16 @@ public final class HealthSteal implements Listener, AutoCloseable {
     public HealthSteal(Settings settings, CharacterStorage characters, EquipmentSessions sessions,
                        Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
                        Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures) {
+        this(settings, characters, sessions, nextTick, healingEvents, nativeLimit, failures, null);
+    }
+
+    public HealthSteal(Settings settings, CharacterStorage characters, EquipmentSessions sessions,
+                       Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
+                       Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures, CombatFeedback feedback) {
         this.settings = Objects.requireNonNull(settings); this.characters = Objects.requireNonNull(characters);
         this.sessions = Objects.requireNonNull(sessions); this.nextTick = Objects.requireNonNull(nextTick);
         this.healingEvents = Objects.requireNonNull(healingEvents); this.nativeLimit = Objects.requireNonNull(nativeLimit);
-        this.failures = Objects.requireNonNull(failures); sources = new CombatSources(sessions);
+        this.failures = Objects.requireNonNull(failures); this.feedback = feedback; sources = new CombatSources(sessions);
     }
 
     public void configure(Settings value) { settings = Objects.requireNonNull(value); }
@@ -187,7 +196,11 @@ public final class HealthSteal implements Listener, AutoCloseable {
             if (attribute == null) return;
             double maximum = Math.min(attribute.getValue(), record.maximumHealth().doubleValue());
             double publish = Math.min(maximum, record.health().doubleValue());
-            if (Double.isFinite(maximum) && Double.isFinite(publish) && publish > nativeBefore) player.setHealth(publish);
+            if (Double.isFinite(maximum) && Double.isFinite(publish) && publish > nativeBefore) {
+                player.setHealth(publish);
+                if (feedback != null) feedback.report("Health Steal", player, AbilityReport.Type.HEALING, player,
+                    BigDecimal.valueOf(publish - nativeBefore).stripTrailingZeros());
+            }
         } finally { finish(character); }
     }
 

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

@@ -0,0 +1,186 @@
+package games.dmg.fantasystick.persistence;
+
+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.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+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;
+
+/** Durable account-owned routine combat/effect feedback preference. */
+public final class PlayerFeedbackPreferences implements AutoCloseable {
+    private static final String FILE = "player-preferences.yml";
+    private static final String PLAYERS = "players";
+    private static final String KEY = "combat-feedback";
+    private static final int MAX_BYTES = 1_048_576;
+
+    public record Update(UUID account, boolean enabled, long sequence) {
+        public Update { Objects.requireNonNull(account); }
+    }
+
+    private final Path directory;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-player-feedback-preferences"));
+    private final Map<UUID, Boolean> effective = new java.util.HashMap<>();
+    private final Map<UUID, Long> published = new java.util.HashMap<>();
+    private long persistedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public PlayerFeedbackPreferences(Path directory) throws IOException {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        effective.putAll(loadEnabled());
+    }
+
+    public synchronized boolean enabled(UUID account) {
+        Objects.requireNonNull(account);
+        return effective.getOrDefault(account, true);
+    }
+
+    public CompletionStage<Update> set(UUID account, boolean enabled) {
+        Objects.requireNonNull(account);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Player preference store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    save(account, enabled);
+                    return new Update(account, enabled, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(new IOException(
+                        "Combat feedback preference save refused or failed; effective setting unchanged", failure));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Player preference store is closed"));
+        }
+    }
+
+    public synchronized boolean publish(Update update) {
+        Objects.requireNonNull(update);
+        if (closed) return false;
+        long previous = published.getOrDefault(update.account(), 0L);
+        if (update.sequence() <= previous) return false;
+        effective.put(update.account(), update.enabled());
+        published.put(update.account(), update.sequence());
+        return true;
+    }
+
+    private Map<UUID, Boolean> loadEnabled() throws IOException {
+        Map<String, Object> root = readRoot();
+        Object rawPlayers = root.get(PLAYERS);
+        if (rawPlayers == null) return Map.of();
+        if (!(rawPlayers instanceof Map<?, ?> players)) throw new IOException("Invalid player preferences");
+        var result = new LinkedHashMap<UUID, Boolean>();
+        for (var entry : players.entrySet()) {
+            if (!(entry.getKey() instanceof String rawId)) throw new IOException("Invalid player preference identity");
+            UUID account;
+            try { account = UUID.fromString(rawId); }
+            catch (IllegalArgumentException invalid) { throw new IOException("Invalid player preference identity", invalid); }
+            if (!(entry.getValue() instanceof Map<?, ?> values)) throw new IOException("Invalid player preference entry");
+            Object raw = values.get(KEY);
+            if (raw == null) continue;
+            if (!(raw instanceof Boolean value)) throw new IOException("Invalid combat feedback preference");
+            result.put(account, value);
+        }
+        return result;
+    }
+
+    private void save(UUID account, boolean enabled) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe data directory");
+        Path lockFile = directory.resolve(".player-preferences.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe preference lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                    LinkOption.NOFOLLOW_LINKS);
+             var ignored = channel.tryLock()) {
+            if (ignored == null) throw new IOException("Player preferences busy");
+            Map<String, Object> root = readRoot();
+            Map<String, Object> players = stringMap(root.get(PLAYERS), "player preferences");
+            Map<String, Object> values = stringMap(players.get(account.toString()), "player preference entry");
+            values.put(KEY, enabled);
+            players.put(account.toString(), values);
+            root.put(PLAYERS, players);
+            byte[] bytes = yaml().dump(root).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Player preferences too large");
+            Path temporary = Files.createTempFile(directory, ".player-preferences-", ".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);
+                }
+                Files.move(temporary, directory.resolve(FILE), StandardCopyOption.ATOMIC_MOVE,
+                    StandardCopyOption.REPLACE_EXISTING);
+                DurableFiles.forceDirectory(directory);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) {
+            throw new IOException("Player preferences busy", busy);
+        }
+    }
+
+    private Map<String, Object> readRoot() throws IOException {
+        Path file = directory.resolve(FILE);
+        if (!Files.exists(file, LinkOption.NOFOLLOW_LINKS)) return new LinkedHashMap<>();
+        if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe player preferences");
+        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("Player preferences too large");
+        Object loaded = yaml().load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+        return stringMap(loaded, "player preference root");
+    }
+
+    private static Map<String, Object> stringMap(Object raw, String label) throws IOException {
+        var result = new LinkedHashMap<String, Object>();
+        if (raw == null) return result;
+        if (!(raw instanceof Map<?, ?> map)) throw new IOException("Invalid " + label);
+        for (var entry : map.entrySet()) {
+            if (!(entry.getKey() instanceof String key)) throw new IOException("Invalid " + label + " key");
+            result.put(key, entry.getValue());
+        }
+        return result;
+    }
+
+    private static Yaml yaml() {
+        var options = new LoaderOptions();
+        options.setAllowDuplicateKeys(false);
+        options.setMaxAliasesForCollections(20);
+        options.setCodePointLimit(MAX_BYTES);
+        return new Yaml(new SafeConstructor(options));
+    }
+
+    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/presentation/CombatFeedback.java

@@ -0,0 +1,84 @@
+package games.dmg.fantasystick.presentation;
+
+import games.dmg.fantasystick.ability.AbilityDefinition;
+import games.dmg.fantasystick.ability.AbilityFeedback;
+import games.dmg.fantasystick.ability.AbilityReport;
+import games.dmg.fantasystick.persistence.PlayerFeedbackPreferences;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Locale;
+import java.util.Objects;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+/** Account-filtered chat presentation for authoritative Fantasy Stick effect outcomes. */
+public final class CombatFeedback implements AbilityFeedback {
+    private final PlayerFeedbackPreferences preferences;
+    private final EquipmentSessions sessions;
+
+    public CombatFeedback(PlayerFeedbackPreferences preferences, EquipmentSessions sessions) {
+        this.preferences = Objects.requireNonNull(preferences);
+        this.sessions = Objects.requireNonNull(sessions);
+    }
+
+    @Override public void report(AbilityDefinition definition, ControlInput input, AbilityReport.Type type,
+                                 Entity target, BigDecimal amount) {
+        Objects.requireNonNull(definition); Objects.requireNonNull(input);
+        report(definition.name(), input.player(), type, target, amount);
+    }
+
+    public void report(String effect, Player source, AbilityReport.Type type, Entity target, BigDecimal amount) {
+        Objects.requireNonNull(effect); Objects.requireNonNull(source); Objects.requireNonNull(type);
+        Objects.requireNonNull(target); Objects.requireNonNull(amount);
+        if (amount.signum() <= 0 || !Double.isFinite(amount.doubleValue())) return;
+        String message = message(effect, type, name(target), amount);
+        if (preferences.enabled(source.getUniqueId())) send(source, message);
+        if (target instanceof Player recipient && recipient != source && recipientEffect(type)
+                && preferences.enabled(recipient.getUniqueId())) send(recipient, message);
+    }
+
+    private String name(Entity entity) {
+        if (entity instanceof Player player) {
+            var active = sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);
+            if (active != null) {
+                var record = sessions.currentRecord(active).orElse(null);
+                if (record != null && !record.name().isBlank()) return record.name();
+            }
+        }
+        String nativeName = entity.getName();
+        if (nativeName != null && !nativeName.isBlank()) return nativeName;
+        var entityType = entity.getType();
+        if (entityType == null) return "Target";
+        String value = entityType.name().toLowerCase(Locale.ROOT).replace('_', ' ');
+        var words = value.split(" ");
+        var result = new StringBuilder();
+        for (String word : words) {
+            if (!result.isEmpty()) result.append(' ');
+            if (!word.isEmpty()) result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1));
+        }
+        return result.toString();
+    }
+
+    private static String message(String effect, AbilityReport.Type type, String target, BigDecimal amount) {
+        String value = amount.setScale(2, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString();
+        return switch (type) {
+            case DAMAGE -> effect + " did " + value + " damage to " + target + ".";
+            case HEALING -> effect + " healed " + target + " for " + value + " health.";
+            case CLEANSING -> effect + " removed " + value + " harmful "
+                + (amount.compareTo(BigDecimal.ONE) == 0 ? "effect" : "effects") + " from " + target + ".";
+            case PREVENTION -> effect + " prevented " + value + " damage to " + target + ".";
+            case BOOST_USED -> effect + " added " + value + " damage against " + target + ".";
+        };
+    }
+
+    private static void send(Player player, String message) {
+        try { player.sendMessage(message); } catch (RuntimeException ignored) { }
+    }
+
+    private static boolean recipientEffect(AbilityReport.Type type) {
+        return type == AbilityReport.Type.HEALING || type == AbilityReport.Type.CLEANSING
+            || type == AbilityReport.Type.PREVENTION;
+    }
+}

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

@@ -353,6 +353,7 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         if (allowed && event.getHand() == EquipmentSlot.HAND && (event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_AIR
                 || event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK)) {
             var selected = sessions.selectedControl(event.getPlayer(), event.getItem()).orElse(null);
+            if (selected != null && !selected.ability().isEmpty() && doorInteraction(event)) return;
             if (selected != null && useGesture(selected)) {
                 org.bukkit.entity.Entity target = selected.ability().equals("hex")
                         || selected.ability().equals("mending_light")
@@ -367,6 +368,12 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         }
     }
 
+    private boolean doorInteraction(org.bukkit.event.player.PlayerInteractEvent event) {
+        var block = event.getClickedBlock();
+        return event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK && block != null
+            && block.getBlockData() instanceof org.bukkit.block.data.type.Door;
+    }
+
     private void beginDraw(Player player, ItemStack item, EquipmentSessions.SelectedControl selected) {
         UUID owner = player.getUniqueId();
         if (closed || draws.containsKey(owner) || player.hasActiveItem()) return;

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

@@ -0,0 +1,68 @@
+package games.dmg.fantasystick.session;
+
+import games.dmg.fantasystick.persistence.PlayerFeedbackPreferences;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.function.Consumer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+
+/** Ordinary-player command for one durable account-owned routine effect-feedback switch. */
+public final class FantasyFeedbackCommand implements TabExecutor, AutoCloseable {
+    private final PlayerFeedbackPreferences preferences;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<Throwable> failures;
+    private boolean closed;
+
+    public FantasyFeedbackCommand(PlayerFeedbackPreferences preferences, Consumer<Runnable> nextTick,
+                                  Consumer<Throwable> failures) {
+        this.preferences = Objects.requireNonNull(preferences);
+        this.nextTick = Objects.requireNonNull(nextTick);
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage("Fantasy feedback is a player-account preference.");
+            return true;
+        }
+        if (args.length == 0) {
+            player.sendMessage("Fantasy feedback is " + state(preferences.enabled(player.getUniqueId())) + ".");
+            return true;
+        }
+        if (args.length != 1 || !(args[0].equals("on") || args[0].equals("off"))) return false;
+        boolean enabled = args[0].equals("on");
+        var account = player.getUniqueId();
+        preferences.set(account, enabled).whenComplete((saved, failure) -> {
+            if (failure != null) report(failure);
+            try {
+                nextTick.accept(() -> {
+                    if (closed) return;
+                    if (failure != null) {
+                        if (player.isOnline()) player.sendMessage(
+                            "Fantasy feedback preference could not be saved; it remains "
+                                + state(preferences.enabled(account)) + ".");
+                        return;
+                    }
+                    boolean published = preferences.publish(saved);
+                    if (player.isOnline()) player.sendMessage("Fantasy feedback is "
+                        + (published ? "now " : "already ") + state(preferences.enabled(account)) + ".");
+                });
+            } catch (RuntimeException rejected) { report(rejected); }
+        });
+        return true;
+    }
+
+    @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        if (!(sender instanceof Player) || args.length != 1) return List.of();
+        String prefix = args[0].toLowerCase(Locale.ROOT);
+        return List.of("off", "on").stream().filter(value -> value.startsWith(prefix)).toList();
+    }
+
+    private static String state(boolean enabled) { return enabled ? "on" : "off"; }
+    private void report(Throwable failure) { try { failures.accept(failure); } catch (RuntimeException ignored) { } }
+    @Override public void close() { closed = true; }
+}

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

@@ -1,6 +1,8 @@
 package games.dmg.fantasystick.session;
 
+import games.dmg.fantasystick.ability.AbilityReport;
 import games.dmg.fantasystick.party.CombatSources;
+import games.dmg.fantasystick.presentation.CombatFeedback;
 import games.dmg.fantasystick.persistence.CharacterRecord;
 import games.dmg.fantasystick.persistence.CharacterStorage;
 import java.math.BigDecimal;
@@ -61,6 +63,7 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
     private final Consumer<EntityRegainHealthEvent> healingEvents;
     private final Supplier<BigDecimal> nativeLimit;
     private final Consumer<Failure> failures;
+    private final CombatFeedback feedback;
     private final CombatSources sources;
     private java.util.function.Function<CharacterRecord, BigInteger> bonusHealing = ignored -> BigInteger.ZERO;
     private final Map<UUID, State> states = new HashMap<>();
@@ -73,11 +76,17 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
     public OutOfCombatRecovery(Settings settings, CharacterStorage characters, EquipmentSessions sessions, Clock clock,
             Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
             Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures) {
+        this(settings, characters, sessions, clock, nextTick, healingEvents, nativeLimit, failures, null);
+    }
+
+    public OutOfCombatRecovery(Settings settings, CharacterStorage characters, EquipmentSessions sessions, Clock clock,
+            Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
+            Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures, CombatFeedback feedback) {
         this.settings = Objects.requireNonNull(settings); this.characters = Objects.requireNonNull(characters);
         this.sessions = Objects.requireNonNull(sessions); this.clock = Objects.requireNonNull(clock);
         this.nextTick = Objects.requireNonNull(nextTick); this.healingEvents = Objects.requireNonNull(healingEvents);
         this.nativeLimit = Objects.requireNonNull(nativeLimit); this.failures = Objects.requireNonNull(failures);
-        sources = new CombatSources(sessions);
+        this.feedback = feedback; sources = new CombatSources(sessions);
     }
 
     public void configure(Settings value) { settings = Objects.requireNonNull(value); }
@@ -225,6 +234,8 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
         double publish = Math.min(maximum, persisted.health().doubleValue());
         if (!Double.isFinite(maximum) || !Double.isFinite(publish) || publish <= nativeBefore) return;
         player.setHealth(publish);
+        if (feedback != null) feedback.report("Out-of-Combat Recovery", player, AbilityReport.Type.HEALING, player,
+            BigDecimal.valueOf(publish - nativeBefore).stripTrailingZeros());
     }
 
     private void remove(UUID owner) {

src/main/resources/plugin.yml

@@ -10,6 +10,9 @@ commands:
     description: Issue or revive sheets, grant fantasy experience, recover sessions or configure Fantasy Stick.
     usage: /fantasystick <give|revive> <online-player> | experience give <active-character-name...> <amount> | <inspect|recover> <player-uuid> | config <setting> [value] | shop <place [name...]|remove <shop-uuid>|list|restock> | party-registrar <place [name...]|remove <registrar-uuid>|list>
     permission: fantasystick.admin
+  fantasyfeedback:
+    description: Read or change routine Fantasy Stick combat and ability feedback for your player account.
+    usage: /fantasyfeedback [on|off]
 permissions:
   fantasystick.admin:
     description: Issue/revive sheets, grant fantasy experience, recover sessions and configure fantasy mode.

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

@@ -80,6 +80,9 @@ class BasicAttackNativeTest {
             assertTrue(parties.leave(a.core.id, party.id()));
             f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, b.player, true));
             assertEquals(2, events.size()); assertFalse(events.getLast().isCancelled());
+            String feedback = "Basic Attack did 1 damage to " + b.core.record.name() + ".";
+            assertEquals(1, a.messages.stream().filter(feedback::equals).count());
+            assertEquals(0, b.messages.stream().filter(feedback::equals).count(), "Targets receive no incoming-damage report");
             f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, b.player, true));
             assertEquals(2, events.size(), "The accepted second hit starts cadence; the cancelled first hit did not");
         }

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

@@ -40,6 +40,7 @@ class ChainLightningNativeTest {
             PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "chain_lightning")); drain(fixture, 2);
             var first = mock(LivingEntity.class); var second = mock(LivingEntity.class);
             locate(first, caster.world, UUID.randomUUID(), 10); locate(second, caster.world, UUID.randomUUID(), 14);
+            when(first.getName()).thenReturn("Zombie"); when(second.getName()).thenReturn("Skeleton");
             doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getLocation();
             doReturn(new Location(caster.world, 0, 65, 0)).when(caster.player).getEyeLocation();
             doReturn(true).when(caster.player).hasLineOfSight(first);
@@ -51,6 +52,8 @@ class ChainLightningNativeTest {
             use(fixture, caster); drain(fixture, 2);
             assertFalse(damage.isEmpty(), caster.messages.toString());
             assertEquals(13, damage.get(first.getUniqueId()), 1.0e-10); assertEquals(9.75, damage.get(second.getUniqueId()), 1.0e-10);
+            assertEquals(1, caster.messages.stream().filter("Chain Lightning did 13 damage to Zombie."::equals).count());
+            assertEquals(1, caster.messages.stream().filter("Chain Lightning did 9.75 damage to Skeleton."::equals).count());
             var stored = ((games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters"))
                 .find(caster.core.record.id()).get().orElseThrow();
             assertEquals(BigInteger.valueOf(39), stored.unspentPoints()); assertTrue(stored.learned().contains("chain_lightning"));

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

@@ -327,8 +327,9 @@ class CharacterBookNativeTest {
             assertTrue(pages.size() <= 100, "Keep each native linked-book view bounded");
             assertTrue(pages.get(0).getString().contains("STR: 0 [+1 STR]"));
             assertTrue(pages.get(0).getString().contains("INT: 12 [+1 INT]"));
-            assertTrue(pages.get(1).getString().startsWith("Current gear"));
-            assertTrue(pages.get(1).getString().contains("Head: Cosmetic"));
+            assertTrue(pages.get(1).getString().startsWith("Gear\n\nHead: Cosmetic\nChestplate:"));
+            assertFalse(pages.get(1).getString().contains("Current gear"));
+            assertFalse(pages.get(1).getString().contains("Cosmetic\nonly"));
             assertTrue(pages.get(2).getString().startsWith("Active abilities"));
             assertTrue(pages.get(2).getString().contains("3: No Ability"));
             int index = firstPageStarting(pages, "Ability index");

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

@@ -1283,6 +1283,40 @@ class EquipmentSessionEventsNativeTest {
         }
     }
 
+    @Test void nativeDoorInteractionTakesPrecedenceOverAbilityUseAndLongbowDraw() throws Exception {
+        try (var f = new Fixture()) {
+            f.loadout("quickstep", "longbow");
+            var a = f.actor; f.core.activate(a);
+            var door = org.mockito.Mockito.mock(org.bukkit.block.Block.class);
+            org.mockito.Mockito.doReturn(org.mockito.Mockito.mock(org.bukkit.block.data.type.Door.class)).when(door).getBlockData();
+            for (int slot : new int[]{2, 3}) {
+                a.inventory.getInventory().setSelectedSlot(slot);
+                var event = new org.bukkit.event.player.PlayerInteractEvent(a.player,
+                    org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK, a.inventory.getItem(slot), door,
+                    org.bukkit.block.BlockFace.UP, org.bukkit.inventory.EquipmentSlot.HAND);
+                event.setUseInteractedBlock(org.bukkit.event.Event.Result.ALLOW);
+                int beforeInputs = f.inputs.size(); int beforeDraws = a.useStarts;
+                f.dispatcher.accept(event);
+                assertEquals(org.bukkit.event.Event.Result.ALLOW, event.useInteractedBlock());
+                assertEquals(org.bukkit.event.Event.Result.DENY, event.useItemInHand());
+                assertEquals(beforeInputs, f.inputs.size(), "A door click is not an ability input");
+                assertEquals(beforeDraws, a.useStarts, "A door click does not begin Longbow drawing");
+            }
+            var stone = org.mockito.Mockito.mock(org.bukkit.block.Block.class);
+            org.mockito.Mockito.doReturn(org.mockito.Mockito.mock(org.bukkit.block.data.BlockData.class)).when(stone).getBlockData();
+            a.inventory.getInventory().setSelectedSlot(2);
+            var ordinaryBlock = new org.bukkit.event.player.PlayerInteractEvent(a.player,
+                org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK, a.inventory.getItem(2), stone,
+                org.bukkit.block.BlockFace.UP, org.bukkit.inventory.EquipmentSlot.HAND);
+            f.dispatcher.accept(ordinaryBlock); assertEquals(1, f.inputs.size(), "Non-door ability use remains active");
+            a.inventory.getInventory().setSelectedSlot(3);
+            var air = new org.bukkit.event.player.PlayerInteractEvent(a.player,
+                org.bukkit.event.block.Action.RIGHT_CLICK_AIR, a.inventory.getItem(3), null,
+                org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND);
+            f.dispatcher.accept(air); assertEquals(1, a.useStarts, "Air use still begins Longbow drawing");
+        }
+    }
+
     @Test void selectedAbilityUseReachesItsHandlerWithoutVanillaThrowDrinkEquipBlockOrPlacement() throws Exception {
         try (var f = new Fixture()) {
             String[] abilities = {"chain_lightning", "purify", "guardian_bond", "shield_bash", "rallying_cry", "frost_nova", "revive"};

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

@@ -0,0 +1,123 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class FantasyFeedbackCommandNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredPlayerCommandDefaultsOnDurablyTurnsOffAndReloadsWithoutAdminPermission() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            assertNotNull(fixture.feedbackCommand);
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(player.core.id, player.player);
+
+            assertTrue(fixture.feedbackCommand.execute(player.player, "fantasyfeedback", new String[]{}));
+            assertEquals("Fantasy feedback is on.", player.messages.getLast());
+            assertEquals(List.of("off", "on"), fixture.feedbackCommand.tabComplete(
+                player.player, "fantasyfeedback", new String[]{""}));
+            assertEquals(List.of("off"), fixture.feedbackCommand.tabComplete(
+                player.player, "fantasyfeedback", new String[]{"of"}));
+
+            int before = player.messages.size();
+            assertTrue(fixture.feedbackCommand.execute(player.player, "fantasyfeedback", new String[]{"off"}));
+            assertEquals(before, player.messages.size(), "queued persistence is not an acknowledged preference change");
+            fixture.tick();
+            assertEquals("Fantasy feedback is now off.", player.messages.getLast());
+
+            fixture.plugin.setEnabled(false);
+            fixture.plugin.setEnabled(true);
+            assertTrue(fixture.feedbackCommand.execute(player.player, "fantasyfeedback", new String[]{}));
+            assertEquals("Fantasy feedback is off.", player.messages.getLast());
+        }
+    }
+
+    @Test void consoleMalformedAndExtraArgumentsCannotChangeAnAccountPreference() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var console = new EquipmentAdminCommandNativeTest.Sender();
+            assertTrue(fixture.feedbackCommand.execute(console.port, "fantasyfeedback", new String[]{"off"}));
+            assertTrue(console.messages.getLast().contains("player-account"));
+            assertTrue(fixture.feedbackCommand.tabComplete(console.port, "fantasyfeedback", new String[]{""}).isEmpty());
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(player.core.id, player.player);
+            assertFalse(fixture.feedbackCommand.getExecutor().onCommand(player.player, fixture.feedbackCommand,
+                "fantasyfeedback", new String[]{"OFF"}));
+            assertFalse(fixture.feedbackCommand.getExecutor().onCommand(player.player, fixture.feedbackCommand,
+                "fantasyfeedback", new String[]{"off", "extra"}));
+            assertTrue(((games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences"))
+                .enabled(player.core.id));
+        }
+    }
+
+    @Test void sourceAndAffectedAccountPreferencesIndependentlyFilterPerTickMessages() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var source = new FantasyStickLifecycleNativeTest.Actor(data);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(source.core.id, source.player);
+            fixture.players.put(target.core.id, target.player);
+            fixture.activate(source); fixture.activate(target);
+            var feedback = (games.dmg.fantasystick.presentation.CombatFeedback)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "combatFeedback");
+
+            feedback.report("Mending Light", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.HEALING, target.player,
+                new java.math.BigDecimal("1.234"));
+            String healing = "Mending Light healed " + target.core.record.name() + " for 1.23 health.";
+            assertEquals(1, source.messages.stream().filter(healing::equals).count());
+            assertEquals(1, target.messages.stream().filter(healing::equals).count());
+
+            fixture.feedbackCommand.execute(source.player, "fantasyfeedback", new String[]{"off"}); fixture.tick();
+            feedback.report("Sanctuary", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.HEALING, target.player,
+                new java.math.BigDecimal("2"));
+            String pulse = "Sanctuary healed " + target.core.record.name() + " for 2 health.";
+            assertEquals(0, source.messages.stream().filter(pulse::equals).count());
+            assertEquals(1, target.messages.stream().filter(pulse::equals).count());
+
+            fixture.feedbackCommand.execute(target.player, "fantasyfeedback", new String[]{"off"}); fixture.tick();
+            feedback.report("Sanctuary", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.HEALING, target.player,
+                new java.math.BigDecimal("2"));
+            assertEquals(0, source.messages.stream().filter(pulse::equals).count());
+            assertEquals(1, target.messages.stream().filter(pulse::equals).count());
+
+            fixture.feedbackCommand.execute(source.player, "fantasyfeedback", new String[]{"on"}); fixture.tick();
+            var zombie = org.mockito.Mockito.mock(org.bukkit.entity.LivingEntity.class);
+            org.mockito.Mockito.when(zombie.getName()).thenReturn("Zombie");
+            org.mockito.Mockito.when(zombie.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            for (int tick = 0; tick < 2; tick++) feedback.report("Burning Ground", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.DAMAGE, zombie,
+                new java.math.BigDecimal("2.345"));
+            assertEquals(2, source.messages.stream()
+                .filter("Burning Ground did 2.35 damage to Zombie."::equals).count());
+            feedback.report("Purify", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.CLEANSING, target.player,
+                new java.math.BigDecimal("2"));
+            feedback.report("Stone Skin", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.PREVENTION, target.player,
+                new java.math.BigDecimal("1.005"));
+            feedback.report("Rallying Cry", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.BOOST_USED, zombie,
+                new java.math.BigDecimal("0.5"));
+            assertTrue(source.messages.contains("Purify removed 2 harmful effects from "
+                + target.core.record.name() + "."));
+            assertTrue(source.messages.contains("Stone Skin prevented 1.01 damage to "
+                + target.core.record.name() + "."));
+            assertTrue(source.messages.contains("Rallying Cry added 0.5 damage against Zombie."));
+            int messages = source.messages.size();
+            feedback.report("No-op", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.DAMAGE, zombie, java.math.BigDecimal.ZERO);
+            assertEquals(messages, source.messages.size());
+        }
+    }
+}

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

@@ -1117,6 +1117,7 @@ class FantasyStickLifecycleNativeTest {
         final Thread main = Thread.currentThread();
         final Map<java.util.UUID, org.bukkit.entity.Player> players = new HashMap<>();
         org.bukkit.command.PluginCommand command;
+        org.bukkit.command.PluginCommand feedbackCommand;
         int playerLookups;
         String failRegistrationAt;
         boolean failRemoval;
@@ -1199,7 +1200,7 @@ class FantasyStickLifecycleNativeTest {
                 case "getWorld" -> players.values().stream().map(org.bukkit.entity.Player::getWorld)
                     .filter(world -> java.util.Objects.equals(world.getUID(), args[0])).findFirst().orElse(null);
                 case "getPlayer" -> { assertSame(main, Thread.currentThread()); playerLookups++; yield players.get(args[0]); }
-                case "getPluginCommand" -> command;
+                case "getPluginCommand" -> "fantasyfeedback".equals(args[0]) ? feedbackCommand : command;
                 case "createInventory" -> args[1] instanceof Integer size
                     ? new org.bukkit.craftbukkit.inventory.CraftInventoryCustom((org.bukkit.inventory.InventoryHolder) args[0], size, (net.kyori.adventure.text.Component) args[2])
                     : new org.bukkit.craftbukkit.inventory.CraftInventoryCustom((org.bukkit.inventory.InventoryHolder) args[0], (org.bukkit.event.inventory.InventoryType) args[1], (net.kyori.adventure.text.Component) args[2]);
@@ -1220,17 +1221,24 @@ class FantasyStickLifecycleNativeTest {
             loader = new Loader(server, data);
             plugin = (JavaPlugin) loader.loadClass("games.dmg.fantasystick.FantasyStickPlugin").getConstructor().newInstance();
             plugin.getLogger().addHandler(logHandler);
+            var constructor = org.bukkit.command.PluginCommand.class.getDeclaredConstructor(String.class, org.bukkit.plugin.Plugin.class);
+            constructor.setAccessible(true);
             var definition = plugin.getDescription().getCommands().get("fantasystick");
             if (definition != null) {
                 // Bukkit normally constructs this from the packaged descriptor during plugin loading.
-                var constructor = org.bukkit.command.PluginCommand.class.getDeclaredConstructor(String.class, org.bukkit.plugin.Plugin.class);
-                constructor.setAccessible(true);
                 command = constructor.newInstance("fantasystick", plugin);
                 command.setPermission((String) definition.get("permission"));
                 // Explicit server-message port: native permission dispatch otherwise reads global Bukkit.server.
                 command.permissionMessage(net.kyori.adventure.text.Component.text("Permission denied"));
                 command.setUsage((String) definition.get("usage"));
             }
+            var feedbackDefinition = plugin.getDescription().getCommands().get("fantasyfeedback");
+            if (feedbackDefinition != null) {
+                feedbackCommand = constructor.newInstance("fantasyfeedback", plugin);
+                feedbackCommand.setPermission((String) feedbackDefinition.get("permission"));
+                feedbackCommand.permissionMessage(net.kyori.adventure.text.Component.text("Permission denied"));
+                feedbackCommand.setUsage((String) feedbackDefinition.get("usage"));
+            }
         }
 
         <T> List<T> packets(org.bukkit.entity.Player viewer, Class<T> type) {

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

@@ -54,6 +54,7 @@ class FireballNativeTest {
             var target = org.mockito.Mockito.mock(org.bukkit.entity.LivingEntity.class);
             org.mockito.Mockito.when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
             org.mockito.Mockito.when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            org.mockito.Mockito.when(target.getName()).thenReturn("Zombie");
             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));
@@ -69,6 +70,7 @@ class FireballNativeTest {
             assertFalse(damages.getFirst().isCancelled());
             assertSame(projectile, damages.getFirst().getDamager());
             assertEquals(org.bukkit.damage.DamageType.FIREBALL, damages.getFirst().getDamageSource().getDamageType());
+            assertEquals(1, a.messages.stream().filter("Fireball did 7 damage to Zombie."::equals).count());
             f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(target, damages.getFirst().getDamageSource(),
                 new java.util.ArrayList<>(), 0));
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
@@ -76,6 +78,8 @@ class FireballNativeTest {
             assertEquals(BigInteger.TEN, rewarded.experience(),
                 "Native projectile attribution reaches the originating character's combat XP");
             assertEquals(5, a.player.getHealth(), "An actual Fireball final blow activates learned Health Steal");
+            assertEquals(1, a.messages.stream().filter(("Health Steal healed " + a.core.record.name()
+                + " for 1 health.")::equals).count());
             assertEquals(0, java.math.BigDecimal.valueOf(5).compareTo(rewarded.health()));
             org.mockito.Mockito.verify(projectile, org.mockito.Mockito.atLeastOnce()).remove();
             f.dispatcher.accept(new org.bukkit.event.entity.ProjectileHitEvent(projectile, target));

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

@@ -55,6 +55,7 @@ class FrostNovaNativeTest {
             fixture.activate(caster); fixture.activate(ally); fixture.activate(opponent); party(fixture, caster, ally);
             var enemy = mock(LivingEntity.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
             when(enemy.getLocation()).thenReturn(new Location(caster.world, 3, 64, 0)); when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(enemy.getName()).thenReturn("Zombie");
             var vetoed = mock(LivingEntity.class); when(vetoed.getUniqueId()).thenReturn(UUID.randomUUID());
             when(vetoed.getLocation()).thenReturn(new Location(caster.world, 2.5, 64, 0));
             doReturn(true).when(caster.player).hasLineOfSight(enemy); doReturn(true).when(caster.player).hasLineOfSight(vetoed);
@@ -79,6 +80,9 @@ class FrostNovaNativeTest {
             use(fixture, caster); drain(fixture, 2);
             assertEquals(8, damage.get(enemy.getUniqueId()), 1.0e-9); assertEquals(8, damage.get(opponent.core.id), 1.0e-9);
             assertEquals(2, damage.size(), "Duplicate, cancelled, party and ordinary targets cannot add accepted hits");
+            assertEquals(1, caster.messages.stream().filter("Frost Nova did 8 damage to Zombie."::equals).count());
+            assertEquals(1, caster.messages.stream().filter(("Frost Nova did 8 damage to "
+                + opponent.core.record.name() + ".")::equals).count());
             assertFalse(vetoedEffects.containsKey(PotionEffectType.SLOWNESS));
             assertEquals(1, enemyEffects.get(PotionEffectType.SLOWNESS).getAmplifier());
             assertEquals(1, opponentEffects.get(PotionEffectType.SLOWNESS).getAmplifier());

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

@@ -6,7 +6,7 @@ class InspireNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()thr
    double maximum=a.maximumHealth.getBaseValue();var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(c->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();a.core.inventory.getInventory().setSelectedSlot(2);f.dispatcher.accept(new PlayerInteractEvent(a.player,org.bukkit.event.block.Action.RIGHT_CLICK_AIR,a.core.inventory.getItem(2),null,org.bukkit.block.BlockFace.SELF,EquipmentSlot.HAND));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);assertEquals(maximum,a.maximumHealth.getBaseValue(),1e-9);assertEquals(120L,f.delayedTicks.getLast());f.delayed.getLast().run();assertEquals(2,absorption.get(),1e-9);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire"));}}
  @Test void aimedPartyAllyActualAbsorptionCreatesPersistedSupportShare()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));
   doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();doReturn(true).when(a.player).hasLineOfSight(b.player);doReturn(b.player).when(a.player).getTargetEntity(64);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);doAnswer(c->absorption.get()).when(b.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(b.player).setAbsorptionAmount(anyDouble());use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(5,absorption.get(),1e-9);
-  var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());when(enemy.getLocation()).thenReturn(new org.bukkit.Location(a.world,8,64,0));var enemySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,3));absorption.set(2.0);PartyBookNativeTest.drain(f);var sourceSheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var holder=new FantasyStickLifecycleNativeTest.Actor(data);holder.core.inventory.setItemInOffHand(sourceSheet);f.players.put(holder.core.id,holder.player);f.activate(holder);
+  var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());when(enemy.getLocation()).thenReturn(new org.bukkit.Location(a.world,8,64,0));var enemySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,3));absorption.set(2.0);PartyBookNativeTest.drain(f);String feedback="Inspire prevented 3 damage to "+b.core.record.name()+".";assertEquals(1,a.messages.stream().filter(feedback::equals).count());assertEquals(1,b.messages.stream().filter(feedback::equals).count());var sourceSheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var holder=new FantasyStickLifecycleNativeTest.Actor(data);holder.core.inventory.setItemInOffHand(sourceSheet);f.players.put(holder.core.id,holder.player);f.activate(holder);
   var allySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(b.player,enemy,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,allySource,3));f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy,allySource,new java.util.ArrayList<>(),0));for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(BigInteger.valueOf(5),storage.find(a.core.record.id()).get().orElseThrow().experience());assertEquals(BigInteger.valueOf(5),storage.find(b.core.record.id()).get().orElseThrow().experience());}}
  @Test void normalSelfOrdinaryOutOfRangeAndObstructedTargetsRefuseBeforeCooldown()throws Exception{for(int route=0;route<4;route++){var dir=data.resolve("refuse-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withInspire(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);org.bukkit.entity.Player target;if(route==0)target=a.player;else if(route==1){target=mock(org.bukkit.entity.Player.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());}else{var b=new FantasyStickLifecycleNativeTest.Actor(dir);target=b.player;f.players.put(b.core.id,b.player);f.activate(b);}doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,route==2?13:8,64,0)).when(target).getLocation();doReturn(route!=3).when(a.player).hasLineOfSight(target);doReturn(target).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("inspire"));}}}
  @Test void nonPartyTargetIsAllowedAndStrongestRemainingCopiesPreserveUnrelatedAbsorption()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-cooldown-seconds: 0\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var c=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);withInspire(data,c,true);f.players.put(a.core.id,a.player);f.players.put(c.core.id,c.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(c);f.activate(b);var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(x->absorption.get()).when(b.player).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(b.player).setAbsorptionAmount(anyDouble());for(var caster:List.of(a,c)){doReturn(false).when(caster.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(caster.player).getLocation();doReturn(true).when(caster.player).hasLineOfSight(b.player);doReturn(b.player).when(caster.player).getTargetEntity(64);}doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","6"});var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();use(f,c);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(9,absorption.get(),1e-9);

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

@@ -68,6 +68,9 @@ class MendingLightNativeTest {
             var healed = storage.find(ally.core.record.id()).get().orElseThrow();
             assertEquals(0, BigDecimal.TEN.compareTo(healed.health()), "6 + WIS modifier caps at ally maximum");
             assertEquals(10, ally.player.getHealth());
+            String feedback = "Mending Light healed " + ally.core.record.name() + " for 6 health.";
+            assertEquals(1, caster.messages.stream().filter(feedback::equals).count());
+            assertEquals(1, ally.messages.stream().filter(feedback::equals).count());
             var deadline = storage.find(caster.core.record.id()).get().orElseThrow().cooldowns().get("mending_light");
             assertNotNull(deadline);
 

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

@@ -49,6 +49,9 @@ class OutOfCombatRecoveryNativeTest {
         assertEquals(4, f.health.get());
         f.runNext();
         assertEquals(5, f.health.get());
+        verify(f.feedback).report(eq("Out-of-Combat Recovery"), eq(f.player),
+            eq(games.dmg.fantasystick.ability.AbilityReport.Type.HEALING), eq(f.player),
+            argThat(amount -> amount.compareTo(BigDecimal.ONE) == 0));
         assertEquals(0, BigDecimal.valueOf(5).compareTo(f.record.get().health()));
 
         f.clock.advance(Duration.ofSeconds(9)); f.recovery.sweep();
@@ -201,6 +204,8 @@ class OutOfCombatRecoveryNativeTest {
     private static final class Direct {
         final CharacterStorage characters = mock(CharacterStorage.class);
         final EquipmentSessions sessions = mock(EquipmentSessions.class);
+        final games.dmg.fantasystick.presentation.CombatFeedback feedback =
+            mock(games.dmg.fantasystick.presentation.CombatFeedback.class);
         final Player player = mock(Player.class);
         final AttributeInstance maximum = mock(AttributeInstance.class);
         final MutableClock clock = new MutableClock();
@@ -242,7 +247,7 @@ class OutOfCombatRecoveryNativeTest {
                     return pending;
                 });
             recovery = new OutOfCombatRecovery(settings, characters, sessions, clock, callbacks::add,
-                event -> { events.add(event); if (veto) event.setCancelled(true); }, () -> BigDecimal.valueOf(1024), ignored -> {});
+                event -> { events.add(event); if (veto) event.setCancelled(true); }, () -> BigDecimal.valueOf(1024), ignored -> {}, feedback);
         }
 
         CharacterRecord saved(BigDecimal target) {

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

@@ -62,6 +62,8 @@ class PurifyNativeTest {
 
             harmful.forEach(type -> assertFalse(effects.containsKey(type), type + " and its hidden chain must be gone"));
             assertTrue(effects.containsKey(PotionEffectType.REGENERATION));
+            assertEquals(1, actor.messages.stream().filter(("Purify removed 4 harmful effects from "
+                + actor.core.record.name() + ".")::equals).count());
             var storage = storage(fixture); var saved = storage.find(actor.core.record.id()).get().orElseThrow();
             var deadline = saved.cooldowns().get("purify"); assertNotNull(deadline);
             actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);

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

@@ -63,12 +63,13 @@ class RallyingCryNativeTest {
             assertNotNull(storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().get("rallying_cry"));
 
             var enemy = mock(LivingEntity.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
-            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE); when(enemy.getName()).thenReturn("Zombie");
             when(enemy.getLocation()).thenReturn(new Location(caster.world, 4, 64, 0)); when(caster.world.getUID()).thenReturn(UUID.randomUUID());
             var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
                 .withCausingEntity(ally.player).withDirectEntity(ally.player).build();
             var hit = new EntityDamageByEntityEvent(ally.player, enemy, EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 10);
             fixture.dispatcher.accept(hit); assertEquals(12, hit.getDamage(), 1.0e-9);
+            assertEquals(1, caster.messages.stream().filter("Rallying Cry added 2 damage against Zombie."::equals).count());
             fixture.dispatcher.accept(new EntityDeathEvent(enemy, source, new ArrayList<>(), 0)); drain(fixture, 4);
             assertEquals(BigInteger.valueOf(5), storage(fixture).find(caster.core.record.id()).get().orElseThrow().experience());
             assertEquals(BigInteger.valueOf(5), storage(fixture).find(ally.core.record.id()).get().orElseThrow().experience());

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

@@ -65,6 +65,8 @@ class SanctuaryNativeTest {
         run(fixture.scheduled, 1); assertEquals(12, fixture.allyHealth.get(), 0); assertEquals(1, fixture.supports.size());
         run(fixture.scheduled, 50); assertEquals(20, fixture.allyHealth.get(), 0, "Six two-point pulses cap at maximum health");
         assertEquals(5, fixture.supports.size(), "The sixth overhealing pulse creates no support evidence");
+        verify(fixture.execution, times(5)).report(eq(AbilityReport.Type.HEALING), eq(fixture.ally),
+            argThat(amount -> amount.compareTo(BigDecimal.valueOf(2)) == 0));
         verify(fixture.execution, atLeastOnce()).finish();
     }
 

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

@@ -40,6 +40,8 @@ class SecondWindNativeTest {
             var saved = storage.find(a.core.record.id()).get().orElseThrow();
             assertEquals(0, BigDecimal.valueOf(11).compareTo(saved.health())); assertEquals(11, a.player.getHealth());
             assertNotNull(saved.cooldowns().get("second_wind"));
+            assertEquals(1, a.messages.stream().filter(("Second Wind healed " + a.core.record.name()
+                + " for 7 health.")::equals).count());
             assertFalse(a.messages.stream().anyMatch(message -> message.contains("support")));
             var sheet = a.core.inventory.getItemInOffHand().clone();
             a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);

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

@@ -100,8 +100,9 @@ class TailBooksNativeTest {
         for (String expected : List.of("Tail of Ari", "Level: 2", "XP: 100", "Unspent points: 30", "Coins: 123",
                 "STR: 0", "DEX: 0", "CON: 10", "INT: 0", "WIS: 0", "CHR: 0")) assertTrue(summary.contains(expected), expected);
         String complete = String.join("", pages).replace("\n", "");
-        for (String expected : List.of("Current gear", "Head: Cosmetic only", "Chestplate: Diamond", "Leggings: Gold", "Boots: Leather"))
+        for (String expected : List.of("GearHead: Cosmetic", "Chestplate: Diamond", "Leggings: Gold", "Boots: Leather"))
             assertTrue(complete.contains(expected), expected);
+        assertFalse(complete.contains("Current gear")); assertFalse(complete.contains("Cosmetic only"));
         String wind = pages.stream().map(p -> p.replace("\n", "")).filter(p -> p.contains("Ability: second_wind")).findFirst().orElseThrow();
         assertTrue(wind.contains("Slots: 1, 3")); assertTrue(wind.contains(expiry.toString()));
         assertFalse(wind.contains("unknown:雪"), "Each learned ability starts its own page/section");

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

@@ -29,8 +29,10 @@ class DistributionTest {
             assertEquals("games.dmg.fantasystick.FantasyStickPlugin", metadata.getMain());
             assertNotNull(metadata.getAPIVersion(), "Declare the native API compatibility contract");
             assertEquals(java.util.List.of("ProtocolLib"), metadata.getDepend());
-            assertEquals(java.util.Set.of("fantasystick"), metadata.getCommands().keySet());
+            assertEquals(java.util.Set.of("fantasystick", "fantasyfeedback"), metadata.getCommands().keySet());
             assertEquals("fantasystick.admin", metadata.getCommands().get("fantasystick").get("permission"));
+            assertNull(metadata.getCommands().get("fantasyfeedback").get("permission"));
+            assertEquals("/fantasyfeedback [on|off]", metadata.getCommands().get("fantasyfeedback").get("usage"));
             assertTrue(metadata.getCommands().get("fantasystick").get("usage").toString().contains("experience give"));
             assertTrue(metadata.getCommands().get("fantasystick").get("usage").toString().contains("shop <place [name...]|remove <shop-uuid>|list|restock>"));
             assertEquals(1, metadata.getPermissions().size());

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

@@ -0,0 +1,59 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class PlayerFeedbackPreferencesTest {
+    @TempDir Path data;
+
+    @Test void defaultsOnAndPublishesOnlyAfterDurableAccountSaveAcrossRestart() throws Exception {
+        UUID account = UUID.randomUUID();
+        PlayerFeedbackPreferences.Update disabled;
+        try (var preferences = new PlayerFeedbackPreferences(data)) {
+            assertTrue(preferences.enabled(account));
+            disabled = preferences.set(account, false).toCompletableFuture().get(5, TimeUnit.SECONDS);
+            assertTrue(preferences.enabled(account), "queued/durable write is not published state");
+            assertTrue(preferences.publish(disabled));
+            assertFalse(preferences.enabled(account));
+        }
+        try (var reopened = new PlayerFeedbackPreferences(data)) {
+            assertFalse(reopened.enabled(account));
+            var enabled = reopened.set(account, true).toCompletableFuture().get(5, TimeUnit.SECONDS);
+            assertTrue(reopened.publish(enabled));
+            assertTrue(reopened.enabled(account));
+        }
+    }
+
+    @Test void concurrentAcknowledgementsCannotPublishStaleStateAndUnrelatedYamlSurvives() throws Exception {
+        UUID account = UUID.randomUUID();
+        java.nio.file.Files.writeString(data.resolve("player-preferences.yml"),
+            "unrelated: keep\nplayers:\n  " + account + ":\n    other: value\n");
+        try (var preferences = new PlayerFeedbackPreferences(data)) {
+            var disabled = preferences.set(account, false).toCompletableFuture().get(5, TimeUnit.SECONDS);
+            var enabled = preferences.set(account, true).toCompletableFuture().get(5, TimeUnit.SECONDS);
+            assertTrue(preferences.publish(enabled));
+            assertFalse(preferences.publish(disabled));
+            assertTrue(preferences.enabled(account));
+        }
+        String saved = java.nio.file.Files.readString(data.resolve("player-preferences.yml"));
+        assertTrue(saved.contains("unrelated: keep"));
+        assertTrue(saved.contains("other: value"));
+        try (var reopened = new PlayerFeedbackPreferences(data)) { assertTrue(reopened.enabled(account)); }
+    }
+
+    @Test void failedOrClosedWritesRetainTheEffectivePreference() throws Exception {
+        UUID account = UUID.randomUUID();
+        var preferences = new PlayerFeedbackPreferences(data);
+        java.nio.file.Files.createDirectory(data.resolve("player-preferences.yml"));
+        assertThrows(Exception.class, () -> preferences.set(account, false).toCompletableFuture().get(5, TimeUnit.SECONDS));
+        assertTrue(preferences.enabled(account));
+        preferences.close();
+        assertThrows(Exception.class, () -> preferences.set(account, false).toCompletableFuture().get(5, TimeUnit.SECONDS));
+        assertTrue(preferences.enabled(account));
+    }
+}