feat(particles): add viewer-specific active auras

README.md

@@ -167,7 +167,7 @@ A same-process retry can acknowledge gear already verified restored for that exa
 
 ## Native fantasy health, exit and defeat
 
-Offhand entry applies actual native maximum health `min(10 + CON, native health limit)`, resumes saved remaining character health, and shows public blue particles. A fresh character's saved health starts full. CON has no gameplay cap; high values do not reject entry. Native damage/healing rules remain in effect, with the existing party/mixed-mode protection. The book reports current native health rather than waiting for an exit save.
+Offhand entry applies actual native maximum health `min(10 + CON, native health limit)`, resumes saved remaining character health, and supplies the recurring blue active-character aura to native viewers who opt in with `/fantasyparticles players on`. The account-owned aura preference defaults to off; `/fantasyparticles players` reports it and `/fantasyparticles players off` hides only this recurring aura. Defeat, progression and ability particles remain unchanged. A fresh character's saved health starts full. CON has no gameplay cap; high values do not reject entry. Native damage/healing rules remain in effect, with the existing party/mixed-mode protection. The book reports current native health rather than waiting for an exit save.
 
 `NativeMaximumHealth` owns only the effective-value cache/dirty callback of that player's existing native maximum-health instance. Base values, modifiers and native potion expiry remain owned by their original sources; nothing is copied back from an old modifier snapshot. The native player health methods and client attribute snapshot are tested. This adapter uses **pinned Purpur 2618 internals**, including private fields; a detached startup probe exercises installation, recalculation and removal before gameplay is registered. Runtime upgrades require renewed native compatibility verification, not a guessed fallback or global attribute-limit changes. Matching native health scaling displays the real fantasy maximum, not a separate virtual health pool; a later unrelated display-scale change is preserved on exit.
 

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

@@ -55,6 +55,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private EquipmentAdminCommand admin;
     private games.dmg.fantasystick.persistence.PlayerFeedbackPreferences feedbackPreferences;
     private games.dmg.fantasystick.session.FantasyFeedbackCommand feedbackCommand;
+    private games.dmg.fantasystick.session.FantasyParticlesCommand particlesCommand;
     private games.dmg.fantasystick.presentation.CombatFeedback combatFeedback;
     private volatile Object lifetime;
     private CharacterPresentation presentation;
@@ -274,6 +275,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
             }
             feedbackCommand = new games.dmg.fantasystick.session.FantasyFeedbackCommand(feedbackPreferences, nextTick,
                 failure -> getLogger().log(Level.WARNING, "Player feedback preference failed", failure));
+            particlesCommand = new games.dmg.fantasystick.session.FantasyParticlesCommand(feedbackPreferences, nextTick,
+                failure -> getLogger().log(Level.WARNING, "Player particle 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.
@@ -616,6 +619,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 "Missing packaged fantasyfeedback command");
             playerFeedbackCommand.setExecutor(feedbackCommand);
             playerFeedbackCommand.setTabCompleter(feedbackCommand);
+            var playerParticlesCommand = java.util.Objects.requireNonNull(getCommand("fantasyparticles"),
+                "Missing packaged fantasyparticles command");
+            playerParticlesCommand.setExecutor(particlesCommand);
+            playerParticlesCommand.setTabCompleter(particlesCommand);
             getServer().getPluginManager().registerEvents(crafting, this);
             getServer().getPluginManager().registerEvents(guard, this);
             getServer().getPluginManager().registerEvents(anvilNames, this);
@@ -672,7 +679,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
             getServer().getPluginManager().registerEvents(books, this);
             getServer().getPluginManager().registerEvents(gameModes, this);
             getServer().getPluginManager().registerEvents(sheetResourcePack, this);
-            sessionVisuals = new games.dmg.fantasystick.session.SessionVisuals(sessions,
+            sessionVisuals = new games.dmg.fantasystick.session.SessionVisuals(sessions, feedbackPreferences,
                 failure -> getLogger().log(Level.WARNING, "Fantasy session particle delivery failed", failure));
             sessionVisuals.install(this);
             recipeRegistered = getServer().addRecipe(new CharacterSheets().recipe());
@@ -698,6 +705,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingChat = chatNames; chatNames = null;
         var closingAdmin = admin; admin = null;
         var closingFeedbackCommand = feedbackCommand; feedbackCommand = null;
+        var closingParticlesCommand = particlesCommand; particlesCommand = null;
         var closingFeedbackPreferences = feedbackPreferences; feedbackPreferences = null;
         combatFeedback = null;
         var closingEvents = sessionEvents; sessionEvents = null;
@@ -806,6 +814,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         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 (closingParticlesCommand != null) cleanup("particles command", closingParticlesCommand::close);
         if (closingFeedbackPreferences != null) cleanup("feedback preferences", closingFeedbackPreferences::close);
         if (closingSettings != null) cleanup("configuration", closingSettings::close);
         if (closingFireballSettings != null) cleanup("Fireball configuration", closingFireballSettings::close);

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

@@ -22,22 +22,35 @@ import org.yaml.snakeyaml.LoaderOptions;
 import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.constructor.SafeConstructor;
 
-/** Durable account-owned routine combat/effect feedback preference. */
+/** Durable account-owned presentation preferences, serialized through one save-before-publish worker. */
 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); }
+    public enum Preference {
+        COMBAT_FEEDBACK("combat-feedback", true),
+        PLAYER_AURAS("player-aura-particles", false),
+        ALL_PARTICLES("all-particles", true);
+
+        private final String key;
+        private final boolean defaultValue;
+        Preference(String key, boolean defaultValue) { this.key = key; this.defaultValue = defaultValue; }
+    }
+
+    private record AccountPreference(UUID account, Preference preference) {
+        private AccountPreference { Objects.requireNonNull(account); Objects.requireNonNull(preference); }
+    }
+
+    public record Update(UUID account, Preference preference, boolean enabled, long sequence) {
+        public Update { Objects.requireNonNull(account); Objects.requireNonNull(preference); }
     }
 
     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 final Map<AccountPreference, Boolean> effective = new java.util.HashMap<>();
+    private final Map<AccountPreference, Long> published = new java.util.HashMap<>();
     private long persistedSequence;
     private boolean closed;
     private int pending;
@@ -48,13 +61,34 @@ public final class PlayerFeedbackPreferences implements AutoCloseable {
         effective.putAll(loadEnabled());
     }
 
-    public synchronized boolean enabled(UUID account) {
+    /** Existing routine combat/effect feedback preference. */
+    public synchronized boolean enabled(UUID account) { return value(account, Preference.COMBAT_FEEDBACK); }
+    public synchronized boolean playerAurasEnabled(UUID account) { return value(account, Preference.PLAYER_AURAS); }
+    public synchronized boolean allParticlesEnabled(UUID account) { return value(account, Preference.ALL_PARTICLES); }
+    public synchronized boolean auraParticlesEnabled(UUID account) {
+        return value(account, Preference.ALL_PARTICLES) && value(account, Preference.PLAYER_AURAS);
+    }
+
+    private boolean value(UUID account, Preference preference) {
         Objects.requireNonNull(account);
-        return effective.getOrDefault(account, true);
+        return effective.getOrDefault(new AccountPreference(account, preference), preference.defaultValue);
     }
 
     public CompletionStage<Update> set(UUID account, boolean enabled) {
-        Objects.requireNonNull(account);
+        return set(account, Preference.COMBAT_FEEDBACK, enabled);
+    }
+
+    public CompletionStage<Update> setPlayerAuras(UUID account, boolean enabled) {
+        return set(account, Preference.PLAYER_AURAS, enabled);
+    }
+
+    /** Shared persisted precedence for the separately delivered all-particles command. */
+    public CompletionStage<Update> setAllParticles(UUID account, boolean enabled) {
+        return set(account, Preference.ALL_PARTICLES, enabled);
+    }
+
+    private CompletionStage<Update> set(UUID account, Preference preference, boolean enabled) {
+        Objects.requireNonNull(account); Objects.requireNonNull(preference);
         synchronized (this) {
             if (closed) return CompletableFuture.failedStage(new IOException("Player preference store is closed"));
             pending++;
@@ -62,11 +96,11 @@ public final class PlayerFeedbackPreferences implements AutoCloseable {
         try {
             return CompletableFuture.supplyAsync(() -> {
                 try {
-                    save(account, enabled);
-                    return new Update(account, enabled, ++persistedSequence);
+                    save(account, preference, enabled);
+                    return new Update(account, preference, 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));
+                        "Player preference save refused or failed; effective setting unchanged", failure));
                 } finally { finished(); }
             }, worker).minimalCompletionStage();
         } catch (RejectedExecutionException rejected) {
@@ -78,34 +112,37 @@ public final class PlayerFeedbackPreferences implements AutoCloseable {
     public synchronized boolean publish(Update update) {
         Objects.requireNonNull(update);
         if (closed) return false;
-        long previous = published.getOrDefault(update.account(), 0L);
+        var key = new AccountPreference(update.account(), update.preference());
+        long previous = published.getOrDefault(key, 0L);
         if (update.sequence() <= previous) return false;
-        effective.put(update.account(), update.enabled());
-        published.put(update.account(), update.sequence());
+        effective.put(key, update.enabled());
+        published.put(key, update.sequence());
         return true;
     }
 
-    private Map<UUID, Boolean> loadEnabled() throws IOException {
+    private Map<AccountPreference, 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>();
+        var result = new LinkedHashMap<AccountPreference, 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);
+            for (var preference : Preference.values()) {
+                Object raw = values.get(preference.key);
+                if (raw == null) continue;
+                if (!(raw instanceof Boolean value)) throw new IOException("Invalid " + preference.key + " preference");
+                result.put(new AccountPreference(account, preference), value);
+            }
         }
         return result;
     }
 
-    private void save(UUID account, boolean enabled) throws IOException {
+    private void save(UUID account, Preference preference, 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");
@@ -118,7 +155,7 @@ public final class PlayerFeedbackPreferences implements AutoCloseable {
             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);
+            values.put(preference.key, enabled);
             players.put(account.toString(), values);
             root.put(PLAYERS, players);
             byte[] bytes = yaml().dump(root).getBytes(StandardCharsets.UTF_8);

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

@@ -0,0 +1,89 @@
+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.UUID;
+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 durable account-owned Fantasy Stick particle preferences. */
+public final class FantasyParticlesCommand implements TabExecutor, AutoCloseable {
+    private final PlayerFeedbackPreferences preferences;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<Throwable> failures;
+    private boolean closed;
+
+    public FantasyParticlesCommand(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 particles are a player-account preference.");
+            return true;
+        }
+        if (args.length == 1 && args[0].equals("players")) {
+            player.sendMessage(status(player.getUniqueId()));
+            return true;
+        }
+        if (args.length != 2 || !args[0].equals("players")
+                || !(args[1].equals("on") || args[1].equals("off"))) return false;
+        boolean enabled = args[1].equals("on");
+        UUID account = player.getUniqueId();
+        preferences.setPlayerAuras(account, enabled).whenComplete((saved, failure) -> {
+            if (failure != null) report(failure);
+            try {
+                nextTick.accept(() -> {
+                    if (closed) return;
+                    if (failure != null) {
+                        if (player.isOnline()) player.sendMessage(
+                            "Active-character aura preference could not be saved; " + status(account));
+                        return;
+                    }
+                    boolean published = preferences.publish(saved);
+                    if (player.isOnline()) player.sendMessage(acknowledgement(account, published));
+                });
+            } catch (RuntimeException rejected) { report(rejected); }
+        });
+        return true;
+    }
+
+    @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        if (!(sender instanceof Player)) return List.of();
+        if (args.length == 1) return matching(List.of("players"), args[0]);
+        if (args.length == 2 && args[0].equals("players")) return matching(List.of("off", "on"), args[1]);
+        return List.of();
+    }
+
+    private String status(UUID account) {
+        boolean saved = preferences.playerAurasEnabled(account);
+        if (saved && !preferences.allParticlesEnabled(account))
+            return "Active-character aura particles are on (effectively off while all particles are off).";
+        return "Active-character aura particles are " + state(saved) + ".";
+    }
+
+    private String acknowledgement(UUID account, boolean published) {
+        boolean saved = preferences.playerAurasEnabled(account);
+        String prefix = "Active-character aura particles are " + (published ? "now " : "already ") + state(saved);
+        if (saved && !preferences.allParticlesEnabled(account))
+            return prefix + " (effectively off while all particles are off).";
+        return prefix + ".";
+    }
+
+    private static List<String> matching(List<String> values, String rawPrefix) {
+        String prefix = rawPrefix.toLowerCase(Locale.ROOT);
+        return values.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/SessionVisuals.java

@@ -11,21 +11,37 @@ import org.bukkit.scheduler.BukkitTask;
 /** Public particles only; never grants gameplay state, protection, health or persistence authority. */
 public final class SessionVisuals implements AutoCloseable {
     private final EquipmentSessions sessions;
+    private final games.dmg.fantasystick.persistence.PlayerFeedbackPreferences preferences;
     private final Consumer<Throwable> failures;
     private BukkitTask task;
     private boolean closed;
 
-    public SessionVisuals(EquipmentSessions sessions, Consumer<Throwable> failures) {
-        this.sessions = Objects.requireNonNull(sessions); this.failures = Objects.requireNonNull(failures);
+    public SessionVisuals(EquipmentSessions sessions,
+                          games.dmg.fantasystick.persistence.PlayerFeedbackPreferences preferences,
+                          Consumer<Throwable> failures) {
+        this.sessions = Objects.requireNonNull(sessions);
+        this.preferences = Objects.requireNonNull(preferences);
+        this.failures = Objects.requireNonNull(failures);
     }
     public void install(Plugin plugin) {
         if (closed || task != null) throw new IllegalStateException("Visual lifetime already used");
         task = plugin.getServer().getScheduler().runTaskTimer(plugin, () -> {
             if (closed) return;
-            for (var player : plugin.getServer().getOnlinePlayers()) {
+            var online = java.util.List.copyOf(plugin.getServer().getOnlinePlayers());
+            for (var source : online) {
                 try {
-                    var active = sessions.active(player.getUniqueId());
-                    if (active.isPresent() && sessions.current(active.orElseThrow())) burst(player, Color.BLUE, 3);
+                    var active = sessions.active(source.getUniqueId());
+                    if (active.isEmpty() || !sessions.current(active.orElseThrow())) continue;
+                    var location = source.getLocation().add(0, 1, 0);
+                    var dust = new Particle.DustOptions(Color.BLUE, 1);
+                    var tracked = source.getTrackedBy();
+                    for (var viewer : online) {
+                        if (!viewer.isOnline() || viewer.getWorld() != source.getWorld()
+                                || (!viewer.getUniqueId().equals(source.getUniqueId()) && !tracked.contains(viewer))
+                                || !viewer.canSee(source)
+                                || !preferences.auraParticlesEnabled(viewer.getUniqueId())) continue;
+                        viewer.spawnParticle(Particle.DUST, location, 3, 0.3, 0.4, 0.3, 0, dust);
+                    }
                 } catch (RuntimeException failure) { failures.accept(failure); }
             }
         }, 1L, 10L);

src/main/resources/plugin.yml

@@ -13,6 +13,9 @@ commands:
   fantasyfeedback:
     description: Read or change routine Fantasy Stick combat and ability feedback for your player account.
     usage: /fantasyfeedback [on|off]
+  fantasyparticles:
+    description: Read or change Fantasy Stick particle visibility for your player account.
+    usage: /fantasyparticles players [on|off]
 permissions:
   fantasystick.admin:
     description: Issue/revive sheets, grant fantasy experience, recover sessions and configure fantasy mode.

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

@@ -64,16 +64,21 @@ class FantasyHealthNativeTest {
         }
     }
 
-    @Test void activeBlueMistAndOneRedDefeatBurstUseWorldLocationsAndStopWithTheSession() throws Exception {
+    @Test void activeBlueMistDefaultsOffWhileOptInAndOneRedDefeatBurstRespectTheirOwnLifetimes() throws Exception {
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
             var a = new FantasyStickLifecycleNativeTest.Actor(data);
             var ordinary = new FantasyStickLifecycleNativeTest.Actor(data); ordinary.core.inventory.setItemInOffHand(null);
             f.players.put(a.core.id, a.player); f.players.put(ordinary.core.id, ordinary.player);
             var entry = a.player.getLocation(); f.activate(a);
-            f.pulses.forEach(Runnable::run);
-            assertTrue(dust(a, org.bukkit.Color.BLUE) > 0, "Active fantasy mode must have visible public blue particles");
-            assertEquals(0, dust(ordinary, org.bukkit.Color.BLUE));
+            f.pulses.getLast().run();
+            assertEquals(0, receivedDust(a, org.bukkit.Color.BLUE), "Active-character auras default off per viewer");
+            assertEquals(0, receivedDust(ordinary, org.bukkit.Color.BLUE));
+            f.particlesCommand.execute(a.player, "fantasyparticles", new String[]{"players", "on"}); f.tick();
+            f.pulses.getLast().run();
+            assertTrue(receivedDust(a, org.bukkit.Color.BLUE) > 0, "An opted-in active viewer sees the current blue aura");
+            assertEquals(0, receivedDust(ordinary, org.bukkit.Color.BLUE));
+            f.particlesCommand.execute(a.player, "fantasyparticles", new String[]{"players", "off"}); f.tick();
             a.core.location.add(20, 0, 20);
             var defeatLocation = a.player.getLocation().add(0, 1, 0);
             var source = new org.bukkit.craftbukkit.damage.CraftDamageSource(new net.minecraft.world.damagesource.DamageSource(
@@ -82,19 +87,19 @@ class FantasyHealthNativeTest {
                 net.kyori.adventure.text.Component.empty(), true);
             f.dispatcher.accept(death); assertTrue(death.isCancelled());
             PartyBookNativeTest.drain(f);
-            assertEquals(1, dust(a, org.bukkit.Color.RED));
+            assertEquals(1, worldDust(a, org.bukkit.Color.RED), "Aura opt-out must not hide the defeat burst");
             assertTrue(org.mockito.Mockito.mockingDetails(a.world).getInvocations().stream().anyMatch(call ->
                 call.getMethod().getName().equals("spawnParticle") && java.util.Arrays.asList(call.getArguments()).contains(defeatLocation)));
             assertEquals(entry, a.player.getLocation()); assertEquals(28, a.player.getHealth());
             var tail = a.core.inventory.getItemInOffHand().clone();
             assertEquals(org.bukkit.Material.WRITTEN_BOOK, tail.getType()); assertEquals(1, tail.getAmount());
-            long blue = dust(a, org.bukkit.Color.BLUE);
+            long blue = receivedDust(a, org.bukkit.Color.BLUE);
             f.pulses.forEach(Runnable::run); f.dispatcher.accept(death);
-            assertEquals(blue, dust(a, org.bukkit.Color.BLUE)); assertEquals(1, dust(a, org.bukkit.Color.RED));
+            assertEquals(blue, receivedDust(a, org.bukkit.Color.BLUE)); assertEquals(1, worldDust(a, org.bukkit.Color.RED));
             assertEquals(tail, a.core.inventory.getItemInOffHand());
             f.plugin.setEnabled(false); f.awaitWorkers();
             f.pulses.forEach(Runnable::run);
-            assertEquals(blue, dust(a, org.bukkit.Color.BLUE), "Retired timers cannot emit fantasy effects");
+            assertEquals(blue, receivedDust(a, org.bukkit.Color.BLUE), "Retired timers cannot emit fantasy effects");
         }
     }
 
@@ -347,12 +352,18 @@ class FantasyHealthNativeTest {
         }
     }
 
-    private static long dust(FantasyStickLifecycleNativeTest.Actor a, org.bukkit.Color color) {
+    private static long worldDust(FantasyStickLifecycleNativeTest.Actor a, org.bukkit.Color color) {
         return org.mockito.Mockito.mockingDetails(a.world).getInvocations().stream().filter(call ->
             call.getMethod().getName().equals("spawnParticle") && java.util.Arrays.stream(call.getArguments())
                 .anyMatch(argument -> argument instanceof org.bukkit.Particle.DustOptions dust && dust.getColor().equals(color))).count();
     }
 
+    private static long receivedDust(FantasyStickLifecycleNativeTest.Actor a, org.bukkit.Color color) {
+        return a.particleCalls.stream().filter(call -> java.util.Arrays.stream(call)
+            .anyMatch(argument -> argument instanceof org.bukkit.Particle.DustOptions dust
+                && dust.getColor().equals(color))).count();
+    }
+
     private static net.minecraft.world.entity.ai.attributes.AttributeModifier modifier(String name, double amount,
             net.minecraft.world.entity.ai.attributes.AttributeModifier.Operation operation) {
         return new net.minecraft.world.entity.ai.attributes.AttributeModifier(net.minecraft.resources.Identifier.fromNamespaceAndPath("test", name), amount, operation);

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

@@ -0,0 +1,228 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Path;
+import java.util.List;
+import org.bukkit.Color;
+import org.bukkit.Particle;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/** Registered account command through the real recurring active-session aura pulse. */
+class FantasyParticlesNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredPlayersRouteDefaultsOffPersistsAndRejectsInvalidSendersAndArguments() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            assertNotNull(fixture.particlesCommand);
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(player.core.id, player.player);
+
+            assertTrue(fixture.particlesCommand.execute(player.player, "fantasyparticles",
+                new String[]{"players"}));
+            assertEquals("Active-character aura particles are off.", player.messages.getLast());
+            assertEquals(List.of("players"), fixture.particlesCommand.tabComplete(
+                player.player, "fantasyparticles", new String[]{""}));
+            assertEquals(List.of("off", "on"), fixture.particlesCommand.tabComplete(
+                player.player, "fantasyparticles", new String[]{"players", ""}));
+            assertEquals(List.of("off"), fixture.particlesCommand.tabComplete(
+                player.player, "fantasyparticles", new String[]{"players", "of"}));
+            assertEquals(List.of("on"), fixture.particlesCommand.tabComplete(
+                player.player, "fantasyparticles", new String[]{"players", "on"}));
+
+            int before = player.messages.size();
+            assertTrue(fixture.particlesCommand.execute(player.player, "fantasyparticles",
+                new String[]{"players", "on"}));
+            assertEquals(before, player.messages.size(), "Persistence must complete before acknowledgement");
+            fixture.tick();
+            assertEquals("Active-character aura particles are now on.", player.messages.getLast());
+            var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
+            var allOff = preferences.setAllParticles(player.core.id, false).toCompletableFuture()
+                .get(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertTrue(preferences.publish(allOff));
+            fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
+            assertEquals("Active-character aura particles are on (effectively off while all particles are off).",
+                player.messages.getLast());
+            var allOn = preferences.setAllParticles(player.core.id, true).toCompletableFuture()
+                .get(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertTrue(preferences.publish(allOn));
+
+            var console = new EquipmentAdminCommandNativeTest.Sender();
+            assertTrue(fixture.particlesCommand.execute(console.port, "fantasyparticles",
+                new String[]{"players", "off"}));
+            assertTrue(console.messages.getLast().contains("player-account"));
+            assertTrue(fixture.particlesCommand.tabComplete(console.port, "fantasyparticles",
+                new String[]{""}).isEmpty());
+            for (String[] invalid : List.of(new String[]{}, new String[]{"all"},
+                    new String[]{"players", "ON"}, new String[]{"players", "on", "extra"})) {
+                assertFalse(fixture.particlesCommand.getExecutor().onCommand(player.player,
+                    fixture.particlesCommand, "fantasyparticles", invalid));
+            }
+
+            var other = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(other.core.id, other.player);
+            var playerSheet = player.core.inventory.getItemInOffHand();
+            player.core.inventory.setItemInOffHand(other.core.inventory.getItemInOffHand());
+            other.core.inventory.setItemInOffHand(playerSheet);
+            fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
+            assertEquals("Active-character aura particles are on.", player.messages.getLast(),
+                "The preference stays with the account after character-sheet switching");
+            fixture.particlesCommand.execute(other.player, "fantasyparticles", new String[]{"players"});
+            assertEquals("Active-character aura particles are off.", other.messages.getLast(),
+                "A transferred character does not transfer its prior holder's preference");
+
+            fixture.plugin.setEnabled(false);
+            fixture.plugin.setEnabled(true);
+            fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
+            assertEquals("Active-character aura particles are on.", player.messages.getLast());
+        }
+    }
+
+    @Test void reversedCompetingCommandCallbacksCannotPublishStaleAuraState() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(player.core.id, player.player);
+            fixture.particlesCommand.execute(player.player, "fantasyparticles",
+                new String[]{"players", "on"});
+            fixture.particlesCommand.execute(player.player, "fantasyparticles",
+                new String[]{"players", "off"});
+            var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
+            preferences.setPlayerAuras(java.util.UUID.randomUUID(), false).toCompletableFuture()
+                .get(5, java.util.concurrent.TimeUnit.SECONDS);
+            var callbacks = new java.util.ArrayList<Runnable>();
+            fixture.tasks.drainTo(callbacks);
+            assertEquals(2, callbacks.size());
+            java.util.Collections.reverse(callbacks); callbacks.forEach(Runnable::run);
+            assertFalse(preferences.playerAurasEnabled(player.core.id));
+            fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
+            assertEquals("Active-character aura particles are off.", player.messages.getLast());
+        }
+    }
+
+    @Test void failedAuraPreferenceSaveKeepsPriorEffectiveStateAndReportsRefusal() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(player.core.id, player.player);
+            java.nio.file.Files.createDirectory(data.resolve("player-preferences.yml"));
+
+            fixture.particlesCommand.execute(player.player, "fantasyparticles",
+                new String[]{"players", "on"});
+            fixture.tick();
+            assertTrue(player.messages.getLast().contains("could not be saved"));
+            fixture.particlesCommand.execute(player.player, "fantasyparticles", new String[]{"players"});
+            assertEquals("Active-character aura particles are off.", player.messages.getLast());
+        }
+    }
+
+    @Test void recurringAuraIsDefaultOffAndDeliveredOnlyToOptedInNativeViewers() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var first = new FantasyStickLifecycleNativeTest.Actor(data); first.accountName = "First";
+            var second = new FantasyStickLifecycleNativeTest.Actor(data); second.accountName = "Second";
+            var enabled = new FantasyStickLifecycleNativeTest.Actor(data); enabled.accountName = "Enabled";
+            var disabled = new FantasyStickLifecycleNativeTest.Actor(data); disabled.accountName = "Disabled";
+            var untracked = new FantasyStickLifecycleNativeTest.Actor(data); untracked.accountName = "Untracked";
+            var hidden = new FantasyStickLifecycleNativeTest.Actor(data); hidden.accountName = "Hidden"; hidden.visible = false;
+            var crossWorld = new FantasyStickLifecycleNativeTest.Actor(data); crossWorld.accountName = "CrossWorld";
+            second.core.location.setWorld(first.world); second.core.location.add(5, 0, 0);
+            enabled.core.location.setWorld(first.world);
+            disabled.core.location.setWorld(first.world);
+            untracked.core.location.setWorld(first.world);
+            hidden.core.location.setWorld(first.world);
+            enabled.core.inventory.setItemInOffHand(null);
+            disabled.core.inventory.setItemInOffHand(null);
+            untracked.core.inventory.setItemInOffHand(null);
+            hidden.core.inventory.setItemInOffHand(null);
+            crossWorld.core.inventory.setItemInOffHand(null);
+            for (var actor : List.of(first, second, enabled, disabled, untracked, hidden, crossWorld))
+                fixture.players.put(actor.core.id, actor.player);
+            first.tracked.add(enabled.player); first.tracked.add(disabled.player); first.tracked.add(hidden.player);
+            first.tracked.add(crossWorld.player);
+            second.tracked.add(enabled.player); second.tracked.add(disabled.player); second.tracked.add(hidden.player);
+            second.tracked.add(first.player);
+            fixture.activate(first); fixture.activate(second);
+            var firstInventory = first.core.snapshot(); var secondInventory = second.core.snapshot();
+            String firstMarker = first.core.marker(); String secondMarker = second.core.marker();
+            clear(first, second, enabled, disabled, untracked, hidden, crossWorld);
+
+            auraPulse(fixture);
+            assertTrue(first.particleCalls.isEmpty());
+            assertTrue(second.particleCalls.isEmpty());
+            assertTrue(enabled.particleCalls.isEmpty());
+            assertTrue(disabled.particleCalls.isEmpty());
+            assertTrue(hidden.particleCalls.isEmpty());
+            org.mockito.Mockito.verify(first.world, org.mockito.Mockito.never()).spawnParticle(
+                org.mockito.ArgumentMatchers.eq(Particle.DUST), org.mockito.ArgumentMatchers.any(org.bukkit.Location.class),
+                org.mockito.ArgumentMatchers.anyInt(), org.mockito.ArgumentMatchers.anyDouble(),
+                org.mockito.ArgumentMatchers.anyDouble(), org.mockito.ArgumentMatchers.anyDouble(),
+                org.mockito.ArgumentMatchers.anyDouble(), org.mockito.ArgumentMatchers.any(Particle.DustOptions.class));
+
+            optIn(fixture, enabled);
+            optIn(fixture, first);
+            optIn(fixture, untracked);
+            optIn(fixture, hidden);
+            optIn(fixture, crossWorld);
+            clear(first, second, enabled, disabled, untracked, hidden, crossWorld);
+            auraPulse(fixture);
+
+            assertEquals(2, blueAuraCalls(enabled).size(), "An ordinary opted-in viewer sees both tracked sources");
+            assertEquals(2, blueAuraCalls(first).size(), "An opted-in active viewer sees self and a tracked peer");
+            assertTrue(disabled.particleCalls.isEmpty(), "Default-off viewers receive no substitute packet");
+            assertTrue(untracked.particleCalls.isEmpty(), "Opt-in does not expand native tracking");
+            assertTrue(hidden.particleCalls.isEmpty(), "Opt-in preserves native player visibility");
+            assertTrue(crossWorld.particleCalls.isEmpty(), "Opt-in does not cross world boundaries");
+            assertEquals(java.util.Set.of(first.player.getLocation().add(0, 1, 0),
+                second.player.getLocation().add(0, 1, 0)), blueAuraCalls(enabled).stream()
+                    .map(call -> (org.bukkit.Location) call[1]).collect(java.util.stream.Collectors.toSet()));
+            for (Object[] call : blueAuraCalls(enabled)) {
+                assertEquals(3, call[2]);
+                assertEquals(0.3, (Double) call[3]); assertEquals(0.4, (Double) call[4]);
+                assertEquals(0.3, (Double) call[5]); assertEquals(0.0, (Double) call[6]);
+            }
+
+            var preferences = (games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences");
+            var allOff = preferences.setAllParticles(enabled.core.id, false).toCompletableFuture()
+                .get(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertTrue(preferences.publish(allOff));
+            clear(enabled); auraPulse(fixture);
+            assertTrue(enabled.particleCalls.isEmpty(), "All-particle off takes precedence over saved aura opt-in");
+            assertTrue(preferences.playerAurasEnabled(enabled.core.id), "Precedence does not overwrite aura preference");
+            var allOn = preferences.setAllParticles(enabled.core.id, true).toCompletableFuture()
+                .get(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertTrue(preferences.publish(allOn));
+            clear(enabled); auraPulse(fixture);
+            assertEquals(2, blueAuraCalls(enabled).size(), "Re-enabling all restores the saved aura preference");
+            assertArrayEquals(firstInventory, first.core.snapshot()); assertArrayEquals(secondInventory, second.core.snapshot());
+            assertEquals(firstMarker, first.core.marker()); assertEquals(secondMarker, second.core.marker());
+        }
+    }
+
+    private static void optIn(FantasyStickLifecycleNativeTest.Fixture fixture,
+                              FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
+        fixture.particlesCommand.execute(actor.player, "fantasyparticles", new String[]{"players", "on"});
+        fixture.tick();
+    }
+
+    private static void auraPulse(FantasyStickLifecycleNativeTest.Fixture fixture) {
+        fixture.pulses.getLast().run();
+    }
+
+    private static List<Object[]> blueAuraCalls(FantasyStickLifecycleNativeTest.Actor actor) {
+        return actor.particleCalls.stream().filter(call -> call[0] == Particle.DUST && call[2].equals(3)
+            && java.util.Arrays.stream(call).anyMatch(value -> value instanceof Particle.DustOptions dust
+                && dust.getColor().equals(Color.BLUE))).toList();
+    }
+
+    private static void clear(FantasyStickLifecycleNativeTest.Actor... actors) {
+        for (var actor : actors) { actor.particles.clear(); actor.particleCalls.clear(); }
+    }
+}

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

@@ -1129,6 +1129,7 @@ class FantasyStickLifecycleNativeTest {
         final Map<java.util.UUID, org.bukkit.entity.Player> players = new HashMap<>();
         org.bukkit.command.PluginCommand command;
         org.bukkit.command.PluginCommand feedbackCommand;
+        org.bukkit.command.PluginCommand particlesCommand;
         int playerLookups;
         String failRegistrationAt;
         boolean failRemoval;
@@ -1211,7 +1212,11 @@ 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" -> "fantasyfeedback".equals(args[0]) ? feedbackCommand : command;
+                case "getPluginCommand" -> switch ((String) args[0]) {
+                    case "fantasyfeedback" -> feedbackCommand;
+                    case "fantasyparticles" -> particlesCommand;
+                    default -> 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]);
@@ -1251,6 +1256,13 @@ class FantasyStickLifecycleNativeTest {
                 feedbackCommand.permissionMessage(net.kyori.adventure.text.Component.text("Permission denied"));
                 feedbackCommand.setUsage((String) feedbackDefinition.get("usage"));
             }
+            var particlesDefinition = plugin.getDescription().getCommands().get("fantasyparticles");
+            if (particlesDefinition != null) {
+                particlesCommand = constructor.newInstance("fantasyparticles", plugin);
+                particlesCommand.setPermission((String) particlesDefinition.get("permission"));
+                particlesCommand.permissionMessage(net.kyori.adventure.text.Component.text("Permission denied"));
+                particlesCommand.setUsage((String) particlesDefinition.get("usage"));
+            }
         }
 
         <T> List<T> packets(org.bukkit.entity.Player viewer, Class<T> type) {
@@ -1353,6 +1365,7 @@ class FantasyStickLifecycleNativeTest {
         boolean healthScaled;
         boolean sprinting;
         boolean allowed = true;
+        boolean visible = true;
         String accountName = "Account";
         double healthScale = 20;
         double absorption;
@@ -1388,7 +1401,7 @@ class FantasyStickLifecycleNativeTest {
                     case "getWorld" -> core.location.getWorld();
                     case "getHeight" -> 1.8;
                     case "getTrackedBy" -> tracked;
-                    case "canSee" -> true;
+                    case "canSee" -> visible;
                     case "getAttribute" -> {
                         assertEquals(org.bukkit.attribute.Attribute.MAX_HEALTH, args[0]);
                         yield new org.bukkit.craftbukkit.attribute.CraftAttributeInstance(maximumHealth, org.bukkit.attribute.Attribute.MAX_HEALTH);

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

@@ -29,11 +29,15 @@ 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", "fantasyfeedback"), metadata.getCommands().keySet());
+            assertEquals(java.util.Set.of("fantasystick", "fantasyfeedback", "fantasyparticles"),
+                metadata.getCommands().keySet());
             assertNull(metadata.getCommands().get("fantasystick").get("permission"),
                 "Player adventure inspection must reach command-level authorization");
             assertNull(metadata.getCommands().get("fantasyfeedback").get("permission"));
+            assertNull(metadata.getCommands().get("fantasyparticles").get("permission"));
             assertEquals("/fantasyfeedback [on|off]", metadata.getCommands().get("fantasyfeedback").get("usage"));
+            assertEquals("/fantasyparticles players [on|off]",
+                metadata.getCommands().get("fantasyparticles").get("usage"));
             assertTrue(metadata.getCommands().get("fantasystick").get("usage").toString().contains("adventure-site"));
             assertTrue(metadata.getCommands().get("fantasystick").get("usage").toString().contains("quest-giver"));
             assertTrue(metadata.getCommands().get("fantasystick").get("usage").toString()

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

@@ -46,14 +46,69 @@ class PlayerFeedbackPreferencesTest {
         try (var reopened = new PlayerFeedbackPreferences(data)) { assertTrue(reopened.enabled(account)); }
     }
 
+    @Test void auraDefaultsOffAndRemainsIndependentUnderAllParticlePrecedenceAcrossRestart() throws Exception {
+        UUID account = UUID.randomUUID();
+        java.nio.file.Files.writeString(data.resolve("player-preferences.yml"),
+            "unrelated: keep\nplayers:\n  " + account + ":\n    combat-feedback: false\n    other: value\n");
+        try (var preferences = new PlayerFeedbackPreferences(data)) {
+            assertFalse(preferences.playerAurasEnabled(account));
+            assertTrue(preferences.allParticlesEnabled(account));
+            assertFalse(preferences.auraParticlesEnabled(account));
+            var auraOn = preferences.setPlayerAuras(account, true).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS);
+            assertFalse(preferences.playerAurasEnabled(account), "Durability precedes effective publication");
+            assertTrue(preferences.publish(auraOn));
+            assertTrue(preferences.auraParticlesEnabled(account));
+            var allOff = preferences.setAllParticles(account, false).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS);
+            assertTrue(preferences.playerAurasEnabled(account), "Changing all preserves the saved aura value");
+            assertTrue(preferences.publish(allOff));
+            assertFalse(preferences.auraParticlesEnabled(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.playerAurasEnabled(account));
+            assertFalse(reopened.allParticlesEnabled(account));
+            assertFalse(reopened.auraParticlesEnabled(account));
+            assertFalse(reopened.enabled(account), "Combat feedback remains independent");
+            var allOn = reopened.setAllParticles(account, true).toCompletableFuture().get(5, TimeUnit.SECONDS);
+            assertTrue(reopened.publish(allOn));
+            assertTrue(reopened.auraParticlesEnabled(account));
+        }
+    }
+
+    @Test void competingAuraWritesRejectStalePublicationAndAcceptedShutdownWorkDrains() throws Exception {
+        UUID account = UUID.randomUUID();
+        var preferences = new PlayerFeedbackPreferences(data);
+        var enabled = preferences.setPlayerAuras(account, true).toCompletableFuture().get(5, TimeUnit.SECONDS);
+        var disabled = preferences.setPlayerAuras(account, false).toCompletableFuture().get(5, TimeUnit.SECONDS);
+        assertTrue(preferences.publish(disabled));
+        assertFalse(preferences.publish(enabled));
+        assertFalse(preferences.playerAurasEnabled(account));
+
+        var accepted = preferences.setPlayerAuras(account, true).toCompletableFuture();
+        preferences.close();
+        preferences.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+        assertNotNull(accepted.get(5, TimeUnit.SECONDS));
+        assertFalse(preferences.playerAurasEnabled(account), "A closed lifetime does not publish its callback");
+        try (var reopened = new PlayerFeedbackPreferences(data)) {
+            assertTrue(reopened.playerAurasEnabled(account), "Accepted shutdown work is durable on restart");
+        }
+    }
+
     @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));
+        assertThrows(Exception.class, () -> preferences.setPlayerAuras(account, true).toCompletableFuture().get(5, TimeUnit.SECONDS));
         assertTrue(preferences.enabled(account));
+        assertFalse(preferences.playerAurasEnabled(account));
         preferences.close();
         assertThrows(Exception.class, () -> preferences.set(account, false).toCompletableFuture().get(5, TimeUnit.SECONDS));
+        assertThrows(Exception.class, () -> preferences.setPlayerAuras(account, true).toCompletableFuture().get(5, TimeUnit.SECONDS));
         assertTrue(preferences.enabled(account));
+        assertFalse(preferences.playerAurasEnabled(account));
     }
 }