From 43fa5162b65300cbba2578b456a2e4f69f38a996 Mon Sep 17 00:00:00 2001 From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com> Date: Wed, 11 Nov 2026 19:16:08 +0100 Subject: [PATCH 1/6] feat: add a hidden /tfmc credits listing the staff, helpers and extra credits /tfmc credits shows everyone holding a global group on the staff and helper LuckPerms tracks (on duty or not, offline players too, each once under their highest section), then the extra lines from tfmc.yml credits.extra (licence credits such as the OGA-BY music by ISAo). It is deliberately kept out of the Brigadier tree, so it is never suggested, tab-completed or listed; TFMCCore answers the typed command in PlayerCommandPreprocessEvent before the tree sees it. Members come from a LuckPerms storage search, cached for credits.cache-seconds (300). Co-Authored-By: Claude Opus 5.5 --- .../net/tfminecraft/tfmccore/TFMCCore.java | 11 +++ .../tfmccore/tfmc/BukkitTfmcActions.java | 62 +++++++++++++++ .../tfmccore/tfmc/TfmcActions.java | 7 ++ .../tfmccore/tfmc/TfmcCommand.java | 78 +++++++++++++++++++ src/main/resources/tfmc.yml | 21 +++++ .../tfmc/BukkitTfmcActionsCoverageTest.java | 56 +++++++++++++ .../tfmccore/tfmc/TfmcCommandTest.java | 69 ++++++++++++++++ 7 files changed, 304 insertions(+) diff --git a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java index c17e664..a6d2d1d 100644 --- a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java +++ b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java @@ -6,7 +6,9 @@ import java.util.Random; import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerCommandPreprocessEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.plugin.java.JavaPlugin; @@ -182,6 +184,15 @@ private void registerTfmcCommand() { public void onQuit(PlayerQuitEvent event) { tfmc.onQuit(event.getPlayer()); } + + // /tfmc credits is kept out of the command tree so nobody is shown it; answer it here + @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true) + public void onCredits(PlayerCommandPreprocessEvent event) { + if (TfmcCommand.isCredits(event.getMessage())) { + event.setCancelled(true); + tfmc.credits(event.getPlayer()); + } + } }, this); } diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java index 7b98db4..8cf4ba9 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java @@ -1,8 +1,14 @@ package net.tfminecraft.tfmccore.tfmc; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; +import java.util.Set; import java.util.UUID; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; @@ -25,6 +31,8 @@ import net.luckperms.api.context.DefaultContextKeys; import net.luckperms.api.context.ImmutableContextSet; import net.luckperms.api.model.user.User; +import net.luckperms.api.model.user.UserManager; +import net.luckperms.api.node.Node; import net.luckperms.api.node.NodeType; import net.luckperms.api.node.types.InheritanceNode; import net.luckperms.api.track.Track; @@ -163,6 +171,60 @@ public CompletableFuture stepTrack(Player player, String trackName, b }); } + @Override + public CompletableFuture>> trackMembers(List trackNames) { + LuckPerms api = luckPerms.get(); + if (api == null) { + return CompletableFuture.failedFuture(new IllegalStateException("LuckPerms is not available")); + } + UserManager users = api.getUserManager(); + // Searches storage, so offline players count too; one search per group on each track + Map>>>> searches = new LinkedHashMap<>(); + for (String name : trackNames) { + Track track = api.getTrackManager().getTrack(name); + List>>> groups = new ArrayList<>(); + if (track == null) { + LOGGER.warning("No LuckPerms track " + name + " for /tfmc credits"); + } else { + for (String group : track.getGroups()) { + groups.add(users.searchAll(api.getNodeMatcherFactory().key("group." + group))); + } + } + searches.put(name, groups); + } + CompletableFuture[] all = searches.values().stream().flatMap(List::stream).toArray(CompletableFuture[]::new); + return CompletableFuture.allOf(all).thenCompose(done -> { + Map> members = new LinkedHashMap<>(); + Map> names = new LinkedHashMap<>(); + searches.forEach((track, groups) -> { + Set ids = new LinkedHashSet<>(); + for (CompletableFuture>> group : groups) { + group.join().forEach((id, nodes) -> { + // Only the stored global group: the same rule track steps follow + if (nodes.stream().anyMatch(node -> node.getValue() && !node.hasExpired() && node.getContexts().isEmpty())) { + ids.add(id); + } + }); + } + members.put(track, ids); + ids.forEach(id -> names.computeIfAbsent(id, unknown -> name(users, unknown))); + }); + return CompletableFuture.allOf(names.values().toArray(CompletableFuture[]::new)).thenApply(named -> { + Map> out = new LinkedHashMap<>(); + members.forEach((track, ids) -> out.put(track, ids.stream() + .map(id -> names.get(id).join()).filter(Objects::nonNull).toList())); + return out; + }); + }); + } + + /** The name as last seen on this server (with its capitals), else LuckPerms' stored one. */ + private static CompletableFuture name(UserManager users, UUID id) { + String seen = Bukkit.getOfflinePlayer(id).getName(); + return seen != null ? CompletableFuture.completedFuture(seen) + : users.lookupUsername(id).exceptionally(error -> null); + } + @Override public FlightState startFlight(Player player, float speed) { FlightState previous = new FlightState(player.getAllowFlight(), player.isFlying(), player.getFlySpeed()); diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java index 66930b3..f0b47c8 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java @@ -1,6 +1,7 @@ package net.tfminecraft.tfmccore.tfmc; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.concurrent.CompletableFuture; @@ -51,6 +52,12 @@ public static TrackStep unchanged() { /** Moves the player one step along a LuckPerms track they are already on. */ CompletableFuture stepTrack(Player player, String track, boolean promote); + /** + * For each track, the names of every player (online or not) holding one of its groups + * globally, on duty or not. Groups held only in a server context do not count. + */ + CompletableFuture>> trackMembers(List tracks); + /** Lets the player fly at {@code speed} and returns their previous flight settings. */ FlightState startFlight(Player player, float speed); diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java index c3d7c86..a846df0 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java @@ -3,10 +3,12 @@ import java.time.Clock; import java.time.LocalDate; import java.util.ArrayList; +import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Optional; +import java.util.Set; import java.util.UUID; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; @@ -62,6 +64,8 @@ private record ParrotFlight(TfmcActions.FlightState previous, Runnable cancelExp private final RandomGenerator random; private final Executor mainThread; private final Map parrots = new ConcurrentHashMap<>(); + private volatile CompletableFuture>> creditMembers; + private volatile long creditMembersAt; /** {@code mainThread} runs LuckPerms completions, which arrive on LuckPerms worker threads. */ public TfmcCommand(TfmcConfig config, TfmcCooldowns cooldowns, TfmcActions actions, Clock clock, @@ -395,6 +399,80 @@ private void poster(Player player, String name) { () -> player.sendMessage(MINI.deserialize("There is no poster called .", Placeholder.unparsed("name", name)))); } + /** One block of /tfmc credits: a title and the LuckPerms tracks whose members it lists. */ + record CreditSection(String title, List tracks) {} + + private static final Pattern CREDITS = Pattern.compile("/(?:tfmccore:)?tfmc\\s+credits\\s*", Pattern.CASE_INSENSITIVE); + + /** + * Whether a typed command is /tfmc credits. That subcommand is deliberately not in the command + * tree, so the client never suggests or completes it; TFMCCore answers it before Brigadier does. + */ + public static boolean isCredits(String message) { + return message != null && CREDITS.matcher(message.trim()).matches(); + } + + /** The sections in tfmc.yml credits.sections, highest first; staff then helpers when none are set. */ + List creditSections() { + List sections = new ArrayList<>(); + for (String key : config.keys("credits.sections")) { + String base = "credits.sections." + key; + sections.add(new CreditSection(config.string(base + ".title", key), config.lines(base + ".tracks"))); + } + if (sections.isEmpty()) { + sections.add(new CreditSection("Staff", List.of("staff"))); + sections.add(new CreditSection("Helpers", List.of("helper+", "helper"))); + } + return sections; + } + + /** + * Shows the credits: everyone on each section's tracks (each player once, in their highest + * section), then the extra lines. Members are looked up at most every credits.cache-seconds, + * since each lookup searches LuckPerms storage. + */ + public void credits(Player player) { + List sections = creditSections(); + List tracks = sections.stream().flatMap(section -> section.tracks().stream()).distinct().toList(); + long now = clock.millis(); + CompletableFuture>> members = creditMembers; + if (members == null || members.isCompletedExceptionally() + || now - creditMembersAt >= config.seconds("credits.cache-seconds") * 1000L) { + members = creditMembers = actions.trackMembers(tracks); + creditMembersAt = now; + } + members.whenCompleteAsync((found, error) -> { + if (error != null) { + LOGGER.warning("Failed to look up the credits: " + error.getMessage()); + } + showCredits(player, sections, error == null ? found : Map.of()); + }, mainThread); + } + + private void showCredits(Player player, List sections, Map> members) { + Set shown = new HashSet<>(); + config.lines("credits.exclude").forEach(name -> shown.add(name.toLowerCase(Locale.ROOT))); + send(player, "credits.header"); + for (CreditSection section : sections) { + List names = new ArrayList<>(); + for (String track : section.tracks()) { + for (String name : members.getOrDefault(track, List.of())) { + if (shown.add(name.toLowerCase(Locale.ROOT))) { + names.add(name); + } + } + } + if (names.isEmpty()) { + continue; + } + names.sort(String.CASE_INSENSITIVE_ORDER); + player.sendMessage(MINI.deserialize(section.title())); + player.sendMessage(MINI.deserialize(config.string("credits.names", ""), + Placeholder.unparsed("names", String.join(", ", names)))); + } + send(player, "credits.extra"); + } + private void update(Player player, CompletableFuture change, String successPath) { change.whenCompleteAsync((done, error) -> { if (error != null) { diff --git a/src/main/resources/tfmc.yml b/src/main/resources/tfmc.yml index ad76df0..e80180e 100644 --- a/src/main/resources/tfmc.yml +++ b/src/main/resources/tfmc.yml @@ -176,6 +176,27 @@ track-messages: removed: "You are no longer on the track." failed: "Your status could not be changed." +# /tfmc credits is deliberately hidden: it is not in the command tree, so it is never suggested, +# tab-completed or listed. It shows header, then each section (highest first) with everyone holding +# one of its LuckPerms tracks' groups globally, on duty or not, each player once in their highest +# section; then extra (credits other licences ask for, and anyone else). exclude: names never listed +# (bots, test accounts). Members are looked up at most every cache-seconds. +credits: + cache-seconds: 300 + header: "TFMC Credits" + sections: + staff: + title: "Staff" + tracks: [staff] + helpers: + title: "Helpers" + tracks: [helper+, helper] + names: "" + exclude: [] + extra: + - "Music" + - "SOUND AIRYLUVS by ISAo airyluvs.com" + # /tfmc poster runs the command as the player. posters: Zerratoris1: "images create https://cdn.imgchest.com/files/yxkczwm8rq7.jpg 42.74553571428" diff --git a/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java b/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java index d03f603..26074d3 100644 --- a/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java @@ -7,6 +7,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.UUID; import java.util.concurrent.CompletableFuture; @@ -286,4 +287,59 @@ private PermissionNode permission(String name, ImmutableContextSet context) { when(node.getContexts()).thenReturn(context); return node; } + + @Test + @SuppressWarnings({"unchecked", "rawtypes"}) + void trackMembersFindEveryoneWithAGlobalGroupOnTheTrackByName() { + LuckPerms api = mock(LuckPerms.class, RETURNS_DEEP_STUBS); + Track staff = mock(Track.class); + when(staff.getGroups()).thenReturn(List.of("staff_player", "staff")); + when(api.getTrackManager().getTrack("staff")).thenReturn(staff); + when(api.getTrackManager().getTrack("missing")).thenReturn(null); + var offDuty = mock(net.luckperms.api.node.matcher.NodeMatcher.class); + var onDuty = mock(net.luckperms.api.node.matcher.NodeMatcher.class); + when(api.getNodeMatcherFactory().key("group.staff_player")).thenReturn(offDuty); + when(api.getNodeMatcherFactory().key("group.staff")).thenReturn(onDuty); + UUID alice = UUID.randomUUID(), devOnly = UUID.randomUUID(), dave = UUID.randomUUID(), lapsed = UUID.randomUUID(); + Map> offDutyFound = new java.util.LinkedHashMap<>(); + offDutyFound.put(alice, List.of(node(true, false, true))); + offDutyFound.put(devOnly, List.of(node(true, false, false))); + Map> onDutyFound = new java.util.LinkedHashMap<>(); + onDutyFound.put(alice, List.of(node(true, false, true))); + onDutyFound.put(dave, List.of(node(true, false, true))); + onDutyFound.put(lapsed, List.of(node(true, true, true), node(false, false, true))); + when(api.getUserManager().searchAll((net.luckperms.api.node.matcher.NodeMatcher) offDuty)) + .thenReturn(CompletableFuture.completedFuture(offDutyFound)); + when(api.getUserManager().searchAll((net.luckperms.api.node.matcher.NodeMatcher) onDuty)) + .thenReturn(CompletableFuture.completedFuture(onDutyFound)); + when(api.getUserManager().lookupUsername(dave)).thenReturn(CompletableFuture.completedFuture("dave")); + try (var bukkit = mockStatic(Bukkit.class)) { + org.bukkit.OfflinePlayer seen = mock(org.bukkit.OfflinePlayer.class); + when(seen.getName()).thenReturn("Alice"); + org.bukkit.OfflinePlayer unseen = mock(org.bukkit.OfflinePlayer.class); + bukkit.when(() -> Bukkit.getOfflinePlayer(alice)).thenReturn(seen); + bukkit.when(() -> Bukkit.getOfflinePlayer(dave)).thenReturn(unseen); + + Map> members = + new BukkitTfmcActions(null, () -> api).trackMembers(List.of("staff", "missing")).join(); + + // Alice once though on two groups; a dev-only group, a lapsed and a negated one do not count + assertEquals(Map.of("staff", List.of("Alice", "dave"), "missing", List.of()), members); + } + CompletionException failure = + assertThrows( + CompletionException.class, + () -> new BukkitTfmcActions(null, () -> null).trackMembers(List.of("staff")).join()); + assertEquals("LuckPerms is not available", failure.getCause().getMessage()); + } + + private static Node node(boolean value, boolean expired, boolean global) { + Node node = mock(Node.class); + ImmutableContextSet contexts = mock(ImmutableContextSet.class); + when(contexts.isEmpty()).thenReturn(global); + when(node.getValue()).thenReturn(value); + when(node.hasExpired()).thenReturn(expired); + when(node.getContexts()).thenReturn(contexts); + return node; + } } diff --git a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java index 1bdb01f..0c10a46 100644 --- a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java @@ -66,6 +66,10 @@ class TfmcCommandTest { private int packsSent; private boolean packRequired; private long clock = NOW.toEpochMilli(); + // Track to the names LuckPerms holds on it, for /tfmc credits + private final Map> members = new HashMap<>(); + private RuntimeException membersFailure; + private int memberLookups; private CommandDispatcher dispatcher; private TfmcConfig config; @@ -93,6 +97,63 @@ public int nextInt(int bound) { dispatcher.getRoot().addChild(command.build()); } + @Test + void creditsStayOutOfTheTreeAndListEachPlayerOnceInTheirHighestSection() throws Exception { + assertTrue(TfmcCommand.isCredits("/tfmc credits")); + assertTrue(TfmcCommand.isCredits(" /TFMC Credits ")); + assertTrue(TfmcCommand.isCredits("/tfmccore:tfmc credits")); + assertFalse(TfmcCommand.isCredits("/tfmc credits now")); + assertFalse(TfmcCommand.isCredits("/tfmc creditss")); + assertFalse(TfmcCommand.isCredits("/tfmc")); + assertFalse(TfmcCommand.isCredits("/credits")); + assertFalse(TfmcCommand.isCredits(null)); + TestPlayer staff = everything("Staffer"); + assertFalse(visible(staff).contains("credits"), "Never suggested, not even to staff"); + assertThrows(CommandSyntaxException.class, () -> run(staff, "tfmc credits"), "Answered before the tree, not by it"); + + String yaml = Files.readString(Path.of("src/main/resources/tfmc.yml")); + config.loadFromString(yaml.replace("exclude: []", "exclude: [TestBot]")); + members.put("staff", List.of("Zed", "Alice")); + members.put("helper+", List.of("alice", "Bob")); + members.put("helper", List.of("carl", "Bob", "testbot")); + TestPlayer steve = player("Steve"); + command.credits(steve.player); + assertTrue(steve.messages.isEmpty(), "Shown on the main thread"); + runMainThread(); + assertEquals(List.of("TFMC Credits", "Staff", "Alice, Zed", "Helpers", "Bob, carl", "Music", + "SOUND AIRYLUVS by ISAo airyluvs.com"), steve.messages); + + // Looked up once per cache-seconds, so the second call still shows the first list + members.put("helper+", List.of("Zed")); + members.put("helper", List.of()); + steve.messages.clear(); + command.credits(steve.player); + runMainThread(); + assertEquals(1, memberLookups); + assertTrue(steve.messages.contains("Bob, carl"), "Still the cached list"); + } + + @Test + void creditsWithoutLuckPermsStillShowTheExtraLinesAndTryAgainNextTime() throws Exception { + membersFailure = new IllegalStateException("LuckPerms is not available"); + TestPlayer steve = player("Steve"); + command.credits(steve.player); + runMainThread(); + assertEquals(List.of("TFMC Credits", "Music", "SOUND AIRYLUVS by ISAo airyluvs.com"), steve.messages); + membersFailure = null; + members.put("staff", List.of("Alice")); + steve.messages.clear(); + command.credits(steve.player); + runMainThread(); + assertEquals(2, memberLookups); + assertTrue(steve.messages.contains("Alice")); + + // Without a credits section: staff, then helpers + config.loadFromString("messages: {}"); + assertEquals(List.of(new TfmcCommand.CreditSection("Staff", List.of("staff")), + new TfmcCommand.CreditSection("Helpers", List.of("helper+", "helper"))), command.creditSections()); + } + @Test void conditionalEventsPathsParseAndCompleteWithoutRunningCoreActions() throws Exception { String yaml = Files.readString(Path.of("src/main/resources/tfmc.yml")); @@ -713,6 +774,14 @@ public Optional highestTrack(Player player, List tracks) { return Optional.ofNullable(highestTracks.get(player.getName())).filter(tracks::contains); } + @Override + public CompletableFuture>> trackMembers(List tracks) { + memberLookups++; + assertEquals(List.of("staff", "helper+", "helper"), tracks); + if (membersFailure != null) return CompletableFuture.failedFuture(membersFailure); + return CompletableFuture.completedFuture(Map.copyOf(members)); + } + @Override public CompletableFuture stepTrack(Player player, String track, boolean promote) { trackSteps.add(player.getName() + " " + track + " " + (promote ? "promote" : "demote")); From e85bbc6a7da0593e6e1d75e48157571aa374e7a6 Mon Sep 17 00:00:00 2001 From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com> Date: Wed, 11 Nov 2026 19:48:32 +0100 Subject: [PATCH 2/6] feat: keep former staff and helpers in /tfmc credits, rank colours, no links - credits-roster.yml remembers everyone the credits listed and the highest section they reached, so staff and helpers who step down stay in (credits.exclude drops someone for good). - Section titles use the TAB rank colours (Staff #f1c40f, Helper #ff00cc) and the header the TAB header colours; names are joined with credits.separator in credits.name format; a footer line closes the list. The music credit has no link. Co-Authored-By: Claude Opus 5.5 --- .../net/tfminecraft/tfmccore/TFMCCore.java | 4 +- .../tfmccore/tfmc/TfmcCommand.java | 75 ++++++++++++---- .../tfmccore/tfmc/TfmcCreditsRoster.java | 86 +++++++++++++++++++ src/main/resources/tfmc.yml | 22 ++--- .../tfmccore/tfmc/TfmcCommandTest.java | 80 ++++++++++++++--- 5 files changed, 226 insertions(+), 41 deletions(-) create mode 100644 src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java diff --git a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java index a6d2d1d..8732799 100644 --- a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java +++ b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java @@ -51,6 +51,7 @@ import net.tfminecraft.tfmccore.stones.StoneListener; import net.tfminecraft.tfmccore.tfmc.BukkitTfmcActions; import net.tfminecraft.tfmccore.tfmc.TfmcCommand; +import net.tfminecraft.tfmccore.tfmc.TfmcCreditsRoster; import net.tfminecraft.tfmccore.tfmc.TfmcConfig; import net.tfminecraft.tfmccore.tfmc.TfmcCooldowns; import net.tfminecraft.tfmccore.whistle.WhistleConfigLoader; @@ -176,7 +177,8 @@ private void registerTfmcCommand() { cooldowns.save(); } TfmcCommand tfmc = tfmcCommand = new TfmcCommand(tfmcConfig, cooldowns, new BukkitTfmcActions(this), - Clock.systemDefaultZone(), new Random(), task -> getServer().getScheduler().runTask(this, task)); + Clock.systemDefaultZone(), new Random(), task -> getServer().getScheduler().runTask(this, task), + new TfmcCreditsRoster(new File(getDataFolder(), "credits-roster.yml"))); getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(tfmc.build(), "TFMC player commands")); getServer().getPluginManager().registerEvents(new Listener() { diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java index a846df0..1015e3b 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java @@ -3,6 +3,7 @@ import java.time.Clock; import java.time.LocalDate; import java.util.ArrayList; +import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Locale; @@ -19,6 +20,7 @@ import java.util.logging.Logger; import java.util.random.RandomGenerator; import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.bukkit.Bukkit; import org.bukkit.Material; @@ -35,6 +37,7 @@ import io.papermc.paper.command.brigadier.CommandSourceStack; import io.papermc.paper.command.brigadier.Commands; +import net.kyori.adventure.text.Component; import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder; import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver; @@ -64,12 +67,20 @@ private record ParrotFlight(TfmcActions.FlightState previous, Runnable cancelExp private final RandomGenerator random; private final Executor mainThread; private final Map parrots = new ConcurrentHashMap<>(); + private final TfmcCreditsRoster creditRoster; private volatile CompletableFuture>> creditMembers; private volatile long creditMembersAt; /** {@code mainThread} runs LuckPerms completions, which arrive on LuckPerms worker threads. */ public TfmcCommand(TfmcConfig config, TfmcCooldowns cooldowns, TfmcActions actions, Clock clock, RandomGenerator random, Executor mainThread) { + this(config, cooldowns, actions, clock, random, mainThread, new TfmcCreditsRoster(null)); + } + + /** {@code creditRoster} remembers everyone /tfmc credits has listed. */ + public TfmcCommand(TfmcConfig config, TfmcCooldowns cooldowns, TfmcActions actions, Clock clock, + RandomGenerator random, Executor mainThread, TfmcCreditsRoster creditRoster) { + this.creditRoster = creditRoster; this.mainThread = mainThread; this.config = config; this.cooldowns = cooldowns; @@ -399,8 +410,8 @@ private void poster(Player player, String name) { () -> player.sendMessage(MINI.deserialize("There is no poster called .", Placeholder.unparsed("name", name)))); } - /** One block of /tfmc credits: a title and the LuckPerms tracks whose members it lists. */ - record CreditSection(String title, List tracks) {} + /** One block of /tfmc credits: its key, title and the LuckPerms tracks whose members it lists. */ + record CreditSection(String key, String title, List tracks) {} private static final Pattern CREDITS = Pattern.compile("/(?:tfmccore:)?tfmc\\s+credits\\s*", Pattern.CASE_INSENSITIVE); @@ -417,19 +428,20 @@ List creditSections() { List sections = new ArrayList<>(); for (String key : config.keys("credits.sections")) { String base = "credits.sections." + key; - sections.add(new CreditSection(config.string(base + ".title", key), config.lines(base + ".tracks"))); + sections.add(new CreditSection(key, config.string(base + ".title", key), config.lines(base + ".tracks"))); } if (sections.isEmpty()) { - sections.add(new CreditSection("Staff", List.of("staff"))); - sections.add(new CreditSection("Helpers", List.of("helper+", "helper"))); + sections.add(new CreditSection("staff", "<#f1c40f>Staff", List.of("staff"))); + sections.add(new CreditSection("helpers", "<#ff00cc>Helpers", List.of("helper+", "helper"))); } return sections; } /** - * Shows the credits: everyone on each section's tracks (each player once, in their highest - * section), then the extra lines. Members are looked up at most every credits.cache-seconds, - * since each lookup searches LuckPerms storage. + * Shows the credits: everyone on each section's tracks and everyone the roster remembers (so + * those who step down stay listed), each player once in their highest section; then the extra + * lines. Members are looked up at most every credits.cache-seconds, since each lookup searches + * LuckPerms storage. */ public void credits(Player player) { List sections = creditSections(); @@ -450,27 +462,54 @@ public void credits(Player player) { } private void showCredits(Player player, List sections, Map> members) { - Set shown = new HashSet<>(); - config.lines("credits.exclude").forEach(name -> shown.add(name.toLowerCase(Locale.ROOT))); - send(player, "credits.header"); + Map ranks = new HashMap<>(); + for (int i = 0; i < sections.size(); i++) { + ranks.putIfAbsent(sections.get(i).key(), i); + } + // Remember who is on the tracks now; the roster keeps their highest section and best spelling + boolean changed = false; for (CreditSection section : sections) { - List names = new ArrayList<>(); for (String track : section.tracks()) { for (String name : members.getOrDefault(track, List.of())) { - if (shown.add(name.toLowerCase(Locale.ROOT))) { - names.add(name); - } + changed |= creditRoster.record(name, section.key(), ranks); } } + } + if (changed) { + creditRoster.save(); + } + Set excluded = new HashSet<>(); + config.lines("credits.exclude").forEach(name -> excluded.add(name.toLowerCase(Locale.ROOT))); + Map roster = creditRoster.players(); + + send(player, "credits.header"); + String nameFormat = config.string("credits.name", ""); + String separator = config.string("credits.separator", ", "); + for (int i = 0; i < sections.size(); i++) { + CreditSection section = sections.get(i); + // The roster is in the order people joined; the top section keeps that, the rest are alphabetical + List names = roster.entrySet().stream() + .filter(entry -> entry.getValue().section().equals(section.key()) && !excluded.contains(entry.getKey())) + .map(entry -> entry.getValue().name()) + .collect(Collectors.toCollection(ArrayList::new)); if (names.isEmpty()) { continue; } - names.sort(String.CASE_INSENSITIVE_ORDER); + if (i > 0) { + names.sort(String.CASE_INSENSITIVE_ORDER); + } + Component line = Component.empty(); + for (int n = 0; n < names.size(); n++) { + if (n > 0) { + line = line.append(MINI.deserialize(separator)); + } + line = line.append(MINI.deserialize(nameFormat, Placeholder.unparsed("name", names.get(n)))); + } player.sendMessage(MINI.deserialize(section.title())); - player.sendMessage(MINI.deserialize(config.string("credits.names", ""), - Placeholder.unparsed("names", String.join(", ", names)))); + player.sendMessage(line); } send(player, "credits.extra"); + send(player, "credits.footer"); } private void update(Player player, CompletableFuture change, String successPath) { diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java new file mode 100644 index 0000000..7037d5d --- /dev/null +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java @@ -0,0 +1,86 @@ +package net.tfminecraft.tfmccore.tfmc; + +import java.io.File; +import java.io.IOException; +import java.util.LinkedHashMap; +import java.util.Locale; +import java.util.Map; +import java.util.logging.Logger; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.file.YamlConfiguration; + +/** + * Everyone /tfmc credits has listed, with the highest section they reached, so staff and helpers + * who later step down stay in the credits. Kept in credits-roster.yml; a null file keeps it in memory. + */ +public final class TfmcCreditsRoster { + + /** A remembered player: the section key they reached and their name as last spelled. */ + public record Entry(String section, String name) {} + + private static final Logger LOGGER = Logger.getLogger("TFMCCore"); + + private final File file; + private final Map players = new LinkedHashMap<>(); + + public TfmcCreditsRoster(File file) { + this.file = file; + if (file != null && file.isFile()) { + ConfigurationSection saved = YamlConfiguration.loadConfiguration(file).getConfigurationSection("players"); + if (saved != null) { + for (String key : saved.getKeys(false)) { + String section = saved.getString(key + ".section", ""); + if (!section.isBlank()) { + players.put(key.toLowerCase(Locale.ROOT), new Entry(section, saved.getString(key + ".name", key))); + } + } + } + } + } + + /** Everyone remembered, in the order they joined their section. */ + public Map players() { + return java.util.Collections.unmodifiableMap(new LinkedHashMap<>(players)); + } + + /** + * Remembers the player in the section if it ranks higher than the one they reached before + * (lower {@code rank} is higher), and keeps the best spelling of their name. True when changed. + */ + public boolean record(String name, String section, Map ranks) { + String key = name.toLowerCase(Locale.ROOT); + Entry old = players.get(key); + String keptSection = old == null || ranks.getOrDefault(section, Integer.MAX_VALUE) + < ranks.getOrDefault(old.section(), Integer.MAX_VALUE) ? section : old.section(); + String keptName = old == null || !name.equals(name.toLowerCase(Locale.ROOT)) ? name : old.name(); + Entry entry = new Entry(keptSection, keptName); + if (entry.equals(old)) { + return false; + } + if (old != null && !old.section().equals(keptSection)) { + players.remove(key); + } + players.put(key, entry); + return true; + } + + public void save() { + if (file == null) { + return; + } + YamlConfiguration out = new YamlConfiguration(); + out.options().setHeader(java.util.List.of( + "Everyone /tfmc credits has listed and the highest section they reached, so former staff", + "and helpers stay in the credits. To drop someone, add them to credits.exclude in tfmc.yml.")); + players.forEach((key, entry) -> { + out.set("players." + key + ".section", entry.section()); + out.set("players." + key + ".name", entry.name()); + }); + try { + out.save(file); + } catch (IOException e) { + LOGGER.warning("Failed to save " + file.getName() + ": " + e.getMessage()); + } + } +} diff --git a/src/main/resources/tfmc.yml b/src/main/resources/tfmc.yml index e80180e..dfe0d3a 100644 --- a/src/main/resources/tfmc.yml +++ b/src/main/resources/tfmc.yml @@ -177,25 +177,27 @@ track-messages: failed: "Your status could not be changed." # /tfmc credits is deliberately hidden: it is not in the command tree, so it is never suggested, -# tab-completed or listed. It shows header, then each section (highest first) with everyone holding -# one of its LuckPerms tracks' groups globally, on duty or not, each player once in their highest -# section; then extra (credits other licences ask for, and anyone else). exclude: names never listed -# (bots, test accounts). Members are looked up at most every cache-seconds. +# tab-completed or listed. Each section lists everyone holding one of its LuckPerms tracks' groups +# globally (on duty or not) and everyone it ever listed (credits-roster.yml), each player once in +# their highest section. Then extra (credits other licences ask for, and anyone else) and footer. +# exclude: names never listed. Members are looked up at most every cache-seconds. credits: cache-seconds: 300 - header: "TFMC Credits" + header: " <#b854f2>❖ <#f4c542>TFMC <#d972f3>Credits <#b854f2>❖ " sections: staff: - title: "Staff" + title: "<#f1c40f>Staff" tracks: [staff] helpers: - title: "Helpers" + title: "<#ff00cc>Helpers" tracks: [helper+, helper] - names: "" + name: "" + separator: " • " exclude: [] extra: - - "Music" - - "SOUND AIRYLUVS by ISAo airyluvs.com" + - "<#5fb8ff>Music" + - "SOUND AIRYLUVS by ISAo" + footer: " " # /tfmc poster runs the command as the player. posters: diff --git a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java index 0c10a46..7535c31 100644 --- a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java @@ -111,26 +111,46 @@ void creditsStayOutOfTheTreeAndListEachPlayerOnceInTheirHighestSection() throws assertFalse(visible(staff).contains("credits"), "Never suggested, not even to staff"); assertThrows(CommandSyntaxException.class, () -> run(staff, "tfmc credits"), "Answered before the tree, not by it"); - String yaml = Files.readString(Path.of("src/main/resources/tfmc.yml")); - config.loadFromString(yaml.replace("exclude: []", "exclude: [TestBot]")); - members.put("staff", List.of("Zed", "Alice")); + credits("exclude: []", "exclude: [TestBot, AltOfZed]"); + members.put("staff", List.of("Zed", "Alice", "altofzed")); members.put("helper+", List.of("alice", "Bob")); members.put("helper", List.of("carl", "Bob", "testbot")); TestPlayer steve = player("Steve"); command.credits(steve.player); assertTrue(steve.messages.isEmpty(), "Shown on the main thread"); runMainThread(); - assertEquals(List.of("TFMC Credits", "Staff", "Alice, Zed", "Helpers", "Bob, carl", "Music", - "SOUND AIRYLUVS by ISAo airyluvs.com"), steve.messages); + assertEquals(List.of("\u2756 TFMC Credits \u2756", "Staff", "Zed \u2022 Alice", "Helpers", "Bob \u2022 carl", "Music", "SOUND AIRYLUVS by ISAo", ""), + trimmed(steve)); + assertFalse(steve.messages.stream().anyMatch(line -> line.contains("http") || line.contains(".com")), "No links"); // Looked up once per cache-seconds, so the second call still shows the first list - members.put("helper+", List.of("Zed")); - members.put("helper", List.of()); + members.put("helper", List.of("Dana")); steve.messages.clear(); command.credits(steve.player); runMainThread(); assertEquals(1, memberLookups); - assertTrue(steve.messages.contains("Bob, carl"), "Still the cached list"); + assertTrue(steve.messages.contains("Bob \u2022 carl"), "Still the cached list"); + } + + @Test + void formerStaffAndHelpersStayInTheCreditsInTheHighestSectionTheyReached() throws Exception { + credits("cache-seconds: 300", "cache-seconds: 0"); + members.put("staff", List.of("Erin", "Alice")); + members.put("helper", List.of("Bob", "Carl")); + TestPlayer steve = player("Steve"); + command.credits(steve.player); + runMainThread(); + // Next lookup: Alice and Carl stepped down, Bob became staff, Dana joined the helpers + clock += 1; + members.clear(); + members.put("staff", List.of("Erin", "bob")); + members.put("helper", List.of("Dana")); + steve.messages.clear(); + command.credits(steve.player); + runMainThread(); + assertEquals(2, memberLookups); + assertEquals(List.of("\u2756 TFMC Credits \u2756", "Staff", "Erin \u2022 Alice \u2022 Bob", "Helpers", "Carl \u2022 Dana", "Music", + "SOUND AIRYLUVS by ISAo", ""), trimmed(steve)); } @Test @@ -139,7 +159,7 @@ void creditsWithoutLuckPermsStillShowTheExtraLinesAndTryAgainNextTime() throws E TestPlayer steve = player("Steve"); command.credits(steve.player); runMainThread(); - assertEquals(List.of("TFMC Credits", "Music", "SOUND AIRYLUVS by ISAo airyluvs.com"), steve.messages); + assertEquals(List.of("\u2756 TFMC Credits \u2756", "Music", "SOUND AIRYLUVS by ISAo", ""), trimmed(steve)); membersFailure = null; members.put("staff", List.of("Alice")); steve.messages.clear(); @@ -148,10 +168,46 @@ void creditsWithoutLuckPermsStillShowTheExtraLinesAndTryAgainNextTime() throws E assertEquals(2, memberLookups); assertTrue(steve.messages.contains("Alice")); - // Without a credits section: staff, then helpers + // Without a credits section: staff, then helpers, in the TAB rank colours config.loadFromString("messages: {}"); - assertEquals(List.of(new TfmcCommand.CreditSection("Staff", List.of("staff")), - new TfmcCommand.CreditSection("Helpers", List.of("helper+", "helper"))), command.creditSections()); + assertEquals(List.of(new TfmcCommand.CreditSection("staff", "<#f1c40f>Staff", List.of("staff")), + new TfmcCommand.CreditSection("helpers", "<#ff00cc>Helpers", List.of("helper+", "helper"))), + command.creditSections()); + } + + /** Loads the shipped tfmc.yml with each pair of strings replaced (old, new, old, new...). */ + private void credits(String... replacements) throws Exception { + String yaml = Files.readString(Path.of("src/main/resources/tfmc.yml")); + for (int i = 0; i < replacements.length; i += 2) { + assertEquals(1, yaml.split(java.util.regex.Pattern.quote(replacements[i]), -1).length - 1, replacements[i]); + yaml = yaml.replace(replacements[i], replacements[i + 1]); + } + config.loadFromString(yaml); + } + + @Test + void theCreditsRosterIsSavedAndReadBack(@org.junit.jupiter.api.io.TempDir Path dir) { + java.io.File file = dir.resolve("credits-roster.yml").toFile(); + Map ranks = Map.of("staff", 0, "helpers", 1); + TfmcCreditsRoster roster = new TfmcCreditsRoster(file); + assertTrue(roster.record("bob", "helpers", ranks)); + assertTrue(roster.record("Cy", "helpers", ranks)); + assertTrue(roster.record("Ann", "staff", ranks)); + assertTrue(roster.record("Bob", "helpers", ranks), "A spelling with capitals wins"); + assertFalse(roster.record("bob", "helpers", ranks), "and is kept over a lowercase one"); + assertTrue(roster.record("bob", "staff", ranks)); + assertFalse(roster.record("Bob", "helpers", ranks), "Never moved down"); + assertEquals(List.of("cy", "ann", "bob"), List.copyOf(roster.players().keySet()), "Moving up puts them last"); + roster.save(); + TfmcCreditsRoster read = new TfmcCreditsRoster(file); + assertEquals(List.of("cy", "ann", "bob"), List.copyOf(read.players().keySet())); + assertEquals(new TfmcCreditsRoster.Entry("staff", "Bob"), read.players().get("bob")); + assertTrue(new TfmcCreditsRoster(dir.resolve("none.yml").toFile()).players().isEmpty()); + new TfmcCreditsRoster(null).save(); + } + + private static List trimmed(TestPlayer player) { + return player.messages.stream().map(String::trim).toList(); } @Test From 136cae1f051646a37a00a2cfcd2b513f138af0d0 Mon Sep 17 00:00:00 2001 From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com> Date: Sun, 15 Nov 2026 02:36:57 +0100 Subject: [PATCH 3/6] Credits: cache without a live credits section, keep an unreadable roster, answer after command gates Review fixes: the lookup cache falls back to 300 s when tfmc.yml has no credits.cache-seconds and a lookup still running is shared; an unreadable credits-roster.yml is left as it is and never saved over, and saves go through a temp file; the handler runs at HIGH so other command gates refuse first. Co-Authored-By: Claude Opus 5.5 --- .../net/tfminecraft/tfmccore/TFMCCore.java | 3 ++- .../tfmccore/tfmc/TfmcCommand.java | 4 +++- .../tfmccore/tfmc/TfmcCreditsRoster.java | 23 ++++++++++++++++--- .../tfmccore/tfmc/TfmcCommandTest.java | 12 ++++++++++ 4 files changed, 37 insertions(+), 5 deletions(-) diff --git a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java index 8732799..354b279 100644 --- a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java +++ b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java @@ -188,7 +188,8 @@ public void onQuit(PlayerQuitEvent event) { } // /tfmc credits is kept out of the command tree so nobody is shown it; answer it here - @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true) + // HIGH so other plugins' command gates (login, jail and the like) refuse it first + @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) public void onCredits(PlayerCommandPreprocessEvent event) { if (TfmcCommand.isCredits(event.getMessage())) { event.setCancelled(true); diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java index 1015e3b..d408e00 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java @@ -448,8 +448,10 @@ public void credits(Player player) { List tracks = sections.stream().flatMap(section -> section.tracks().stream()).distinct().toList(); long now = clock.millis(); CompletableFuture>> members = creditMembers; + // A live tfmc.yml without the credits section still caches (300 s), and a lookup still running is shared. + long cacheSeconds = (long) config.decimal("credits.cache-seconds", 300); if (members == null || members.isCompletedExceptionally() - || now - creditMembersAt >= config.seconds("credits.cache-seconds") * 1000L) { + || (members.isDone() && now - creditMembersAt >= cacheSeconds * 1000L)) { members = creditMembers = actions.trackMembers(tracks); creditMembersAt = now; } diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java index 7037d5d..c5870f3 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java @@ -2,12 +2,15 @@ import java.io.File; import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.StandardCopyOption; import java.util.LinkedHashMap; import java.util.Locale; import java.util.Map; import java.util.logging.Logger; import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.InvalidConfigurationException; import org.bukkit.configuration.file.YamlConfiguration; /** @@ -23,11 +26,22 @@ public record Entry(String section, String name) {} private final File file; private final Map players = new LinkedHashMap<>(); + /** The file could not be read: it is left as it is and never overwritten until fixed and reloaded. */ + private boolean readOnly; public TfmcCreditsRoster(File file) { this.file = file; if (file != null && file.isFile()) { - ConfigurationSection saved = YamlConfiguration.loadConfiguration(file).getConfigurationSection("players"); + YamlConfiguration yaml = new YamlConfiguration(); + try { + yaml.load(file); + } catch (IOException | InvalidConfigurationException e) { + readOnly = true; + LOGGER.warning("Could not read " + file.getName() + " (" + e.getMessage() + + "); it is left untouched and not saved until it is fixed."); + return; + } + ConfigurationSection saved = yaml.getConfigurationSection("players"); if (saved != null) { for (String key : saved.getKeys(false)) { String section = saved.getString(key + ".section", ""); @@ -66,7 +80,7 @@ public boolean record(String name, String section, Map ranks) { } public void save() { - if (file == null) { + if (file == null || readOnly) { return; } YamlConfiguration out = new YamlConfiguration(); @@ -77,8 +91,11 @@ public void save() { out.set("players." + key + ".section", entry.section()); out.set("players." + key + ".name", entry.name()); }); + // Written beside it and moved into place, so a crash mid-write never leaves half a roster. + File temp = new File(file.getParentFile(), file.getName() + ".tmp"); try { - out.save(file); + out.save(temp); + Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE); } catch (IOException e) { LOGGER.warning("Failed to save " + file.getName() + ": " + e.getMessage()); } diff --git a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java index 7535c31..a101786 100644 --- a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java @@ -206,6 +206,18 @@ void theCreditsRosterIsSavedAndReadBack(@org.junit.jupiter.api.io.TempDir Path d new TfmcCreditsRoster(null).save(); } + @Test + void anUnreadableRosterIsNeverOverwritten(@org.junit.jupiter.api.io.TempDir Path dir) throws Exception { + Path file = dir.resolve("credits-roster.yml"); + String broken = "players:\n bob: [unclosed\n"; + Files.writeString(file, broken); + TfmcCreditsRoster roster = new TfmcCreditsRoster(file.toFile()); + assertTrue(roster.players().isEmpty()); + assertTrue(roster.record("Ann", "staff", Map.of("staff", 0))); + roster.save(); + assertEquals(broken, Files.readString(file), "The hand-edited file is kept as it was"); + } + private static List trimmed(TestPlayer player) { return player.messages.stream().map(String::trim).toList(); } From 5ebb0ff051b3670c887ded13ad6cc32d7a36febe Mon Sep 17 00:00:00 2001 From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com> Date: Sun, 15 Nov 2026 02:46:25 +0100 Subject: [PATCH 4/6] Credits: give up on a lookup stuck for a minute; fall back when an atomic move is refused Co-Authored-By: Claude Opus 5.5 --- .../java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java | 4 +++- .../net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java | 8 ++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java index d408e00..03b031e 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java @@ -450,8 +450,10 @@ public void credits(Player player) { CompletableFuture>> members = creditMembers; // A live tfmc.yml without the credits section still caches (300 s), and a lookup still running is shared. long cacheSeconds = (long) config.decimal("credits.cache-seconds", 300); + // A lookup that hangs for a minute is given up on, so one stuck search never silences the command. if (members == null || members.isCompletedExceptionally() - || (members.isDone() && now - creditMembersAt >= cacheSeconds * 1000L)) { + || (members.isDone() && now - creditMembersAt >= cacheSeconds * 1000L) + || (!members.isDone() && now - creditMembersAt >= 60_000L)) { members = creditMembers = actions.trackMembers(tracks); creditMembersAt = now; } diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java index c5870f3..2f9b3f6 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java @@ -38,7 +38,7 @@ public TfmcCreditsRoster(File file) { } catch (IOException | InvalidConfigurationException e) { readOnly = true; LOGGER.warning("Could not read " + file.getName() + " (" + e.getMessage() - + "); it is left untouched and not saved until it is fixed."); + + "); it is left untouched and not saved until it is fixed and the server restarts."); return; } ConfigurationSection saved = yaml.getConfigurationSection("players"); @@ -95,7 +95,11 @@ public void save() { File temp = new File(file.getParentFile(), file.getName() + ".tmp"); try { out.save(temp); - Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE); + try { + Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE); + } catch (java.nio.file.AtomicMoveNotSupportedException e) { + Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING); + } } catch (IOException e) { LOGGER.warning("Failed to save " + file.getName() + ": " + e.getMessage()); } From cd774f058a9ca2a380a4e153f2215a88bab9e2f4 Mon Sep 17 00:00:00 2001 From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com> Date: Sun, 15 Nov 2026 02:59:38 +0100 Subject: [PATCH 5/6] Credits: cover the hidden command listener and a failed roster save; plain replace on save Co-Authored-By: Claude Opus 5.5 --- .../tfmccore/tfmc/TfmcCreditsRoster.java | 6 +----- .../tfmccore/PluginLifecycleCoverageTest.java | 13 +++++++++++++ .../tfminecraft/tfmccore/tfmc/TfmcCommandTest.java | 6 ++++++ 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java index 2f9b3f6..b1c2a89 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java @@ -95,11 +95,7 @@ public void save() { File temp = new File(file.getParentFile(), file.getName() + ".tmp"); try { out.save(temp); - try { - Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE); - } catch (java.nio.file.AtomicMoveNotSupportedException e) { - Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING); - } + Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { LOGGER.warning("Failed to save " + file.getName() + ": " + e.getMessage()); } diff --git a/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java b/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java index e17bde8..5655832 100644 --- a/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java @@ -78,6 +78,7 @@ import org.bukkit.enchantments.Enchantment; import org.bukkit.entity.Player; import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerCommandPreprocessEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.PluginDescriptionFile; @@ -326,6 +327,18 @@ void startupRegistersCommandsListenersAndTheActualLifecycleAndQuitCallbacks() th new PlayerQuitEvent( rig.player, Component.empty(), PlayerQuitEvent.QuitReason.DISCONNECTED)); verify(rig.commands.constructed().getFirst()).onQuit(rig.player); + var onCredits = quit.getClass().getDeclaredMethod("onCredits", PlayerCommandPreprocessEvent.class); + onCredits.setAccessible(true); + PlayerCommandPreprocessEvent credits = mock(PlayerCommandPreprocessEvent.class); + when(credits.getMessage()).thenReturn("/tfmc credits"); + when(credits.getPlayer()).thenReturn(rig.player); + onCredits.invoke(quit, credits); + verify(credits).setCancelled(true); + verify(rig.commands.constructed().getFirst()).credits(rig.player); + PlayerCommandPreprocessEvent other = mock(PlayerCommandPreprocessEvent.class); + when(other.getMessage()).thenReturn("/tfmc patreon"); + onCredits.invoke(quit, other); + verify(other, never()).setCancelled(true); rig.plugin.onDisable(); diff --git a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java index a101786..e37c300 100644 --- a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java @@ -216,6 +216,12 @@ void anUnreadableRosterIsNeverOverwritten(@org.junit.jupiter.api.io.TempDir Path assertTrue(roster.record("Ann", "staff", Map.of("staff", 0))); roster.save(); assertEquals(broken, Files.readString(file), "The hand-edited file is kept as it was"); + Path blocked = dir.resolve("blocked"); + Files.createDirectories(blocked.resolve("inside")); + TfmcCreditsRoster unwritable = new TfmcCreditsRoster(blocked.toFile()); + assertTrue(unwritable.record("Ann", "staff", Map.of("staff", 0))); + unwritable.save(); + assertTrue(Files.isDirectory(blocked.resolve("inside")), "A failed save is only logged"); } private static List trimmed(TestPlayer player) { From ba2728e4bbea2bed61c35f69a55b0deb584c0905 Mon Sep 17 00:00:00 2001 From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com> Date: Sun, 15 Nov 2026 03:07:22 +0100 Subject: [PATCH 6/6] Credits: a hung lookup times out after a minute so waiting players get the remembered names (CodeRabbit) Co-Authored-By: Claude Opus 5.5 --- .../java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java index 03b031e..bfa3f10 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java @@ -14,6 +14,7 @@ import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Executor; +import java.util.concurrent.TimeUnit; import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.Supplier; @@ -450,11 +451,10 @@ public void credits(Player player) { CompletableFuture>> members = creditMembers; // A live tfmc.yml without the credits section still caches (300 s), and a lookup still running is shared. long cacheSeconds = (long) config.decimal("credits.cache-seconds", 300); - // A lookup that hangs for a minute is given up on, so one stuck search never silences the command. if (members == null || members.isCompletedExceptionally() - || (members.isDone() && now - creditMembersAt >= cacheSeconds * 1000L) - || (!members.isDone() && now - creditMembersAt >= 60_000L)) { - members = creditMembers = actions.trackMembers(tracks); + || (members.isDone() && now - creditMembersAt >= cacheSeconds * 1000L)) { + // A lookup that hangs for a minute fails, so everyone waiting gets the remembered names instead. + members = creditMembers = actions.trackMembers(tracks).orTimeout(60, TimeUnit.SECONDS); creditMembersAt = now; } members.whenCompleteAsync((found, error) -> {