diff --git a/gradle.properties b/gradle.properties index b6e4c8a..21567c2 100644 --- a/gradle.properties +++ b/gradle.properties @@ -8,7 +8,7 @@ loader_version=0.19.3 fabric_version=0.141.4+1.21.11 loom_version=1.17.8 -mod_version=1.6.6 +mod_version=1.6.7-beta.3 maven_group=tel.eden archives_base_name=edenmod modmenu_version=17.0.0 diff --git a/resources/assets/edenmod/textures/gui/cycle/medal_1.png b/resources/assets/edenmod/textures/gui/cycle/medal_1.png new file mode 100644 index 0000000..0bd0507 Binary files /dev/null and b/resources/assets/edenmod/textures/gui/cycle/medal_1.png differ diff --git a/resources/assets/edenmod/textures/gui/cycle/medal_2.png b/resources/assets/edenmod/textures/gui/cycle/medal_2.png new file mode 100644 index 0000000..a91f1b6 Binary files /dev/null and b/resources/assets/edenmod/textures/gui/cycle/medal_2.png differ diff --git a/resources/assets/edenmod/textures/gui/cycle/medal_3.png b/resources/assets/edenmod/textures/gui/cycle/medal_3.png new file mode 100644 index 0000000..5307a9f Binary files /dev/null and b/resources/assets/edenmod/textures/gui/cycle/medal_3.png differ diff --git a/src/tel/eden/mod/EdenModClient.java b/src/tel/eden/mod/EdenModClient.java index 49662d7..a9e831d 100644 --- a/src/tel/eden/mod/EdenModClient.java +++ b/src/tel/eden/mod/EdenModClient.java @@ -248,6 +248,8 @@ public boolean isFullMember() { /** Guild-only commands are hidden from travelers; an unverified player keeps them, as before. */ private final java.util.function.Predicate guildOnly = source -> !isTraveler(); + /** Member-only commands (events/cycle leaderboards) are hidden from travelers AND observers. */ + private final java.util.function.Predicate fullMemberOnly = source -> isFullMember(); /** In-game guild rank last reported by the backend, or empty if unknown. */ public String liveGuildRank() { @@ -294,6 +296,32 @@ public boolean onWynncraft() { private volatile String longEventError = ""; private volatile long longEventErrorAtMs; private final java.util.concurrent.atomic.AtomicInteger longEventGeneration = new java.util.concurrent.atomic.AtomicInteger(); + private volatile tel.eden.mod.net.CycleLeaderboardData.CycleSnapshot knownCycleLeaderboard; + private volatile String cycleLeaderboardError = ""; + private volatile long cycleLeaderboardErrorAtMs; + private final java.util.concurrent.atomic.AtomicInteger cycleLeaderboardGeneration = new java.util.concurrent.atomic.AtomicInteger(); + private volatile tel.eden.mod.net.CycleLeaderboardData.LifetimeSnapshot knownLifetimeLeaderboard; + private volatile String lifetimeLeaderboardError = ""; + private volatile long lifetimeLeaderboardErrorAtMs; + private final java.util.concurrent.atomic.AtomicInteger lifetimeLeaderboardGeneration = new java.util.concurrent.atomic.AtomicInteger(); + private final java.util.Map concludedCyclesByCode = new java.util.concurrent.ConcurrentHashMap<>(); + + private record LifetimeFilter(Double fromDays, Double toDays) { + } + + private volatile String pendingCyclePrintCode; + private volatile String pendingCycleGuiCode; + private volatile LifetimeFilter pendingLifetimeFilter; + private static final long LEADERBOARD_TIMEOUT_SECONDS = 15L; + private final java.util.concurrent.atomic.AtomicLong cycleGuiSeq = new java.util.concurrent.atomic.AtomicLong(); + private final java.util.concurrent.atomic.AtomicLong cycleGuiPendingId = new java.util.concurrent.atomic.AtomicLong(); + private final java.util.concurrent.atomic.AtomicLong cyclePrintSeq = new java.util.concurrent.atomic.AtomicLong(); + private final java.util.concurrent.atomic.AtomicLong cyclePrintPendingId = new java.util.concurrent.atomic.AtomicLong(); + private final java.util.concurrent.atomic.AtomicLong lifetimeRequestSeq = new java.util.concurrent.atomic.AtomicLong(); + private final java.util.concurrent.atomic.AtomicLong lifetimeRequestPendingId = new java.util.concurrent.atomic.AtomicLong(); + private final Object cycleSendLock = new Object(); + private volatile long lastCycleQueryAtMs; + private volatile long lastLifetimeQueryAtMs; // GitHub update check: run once per game session; the prompt offers a one-click // download (applied on game close) and a link to the release page. private final UpdateChecker updateChecker = new UpdateChecker(); @@ -575,6 +603,42 @@ public int longEventGeneration() { return longEventGeneration.get(); } + /** Latest promotion-cycle leaderboard snapshot, or {@code null} before first reply. */ + public tel.eden.mod.net.CycleLeaderboardData.CycleSnapshot knownCycleLeaderboard() { + return knownCycleLeaderboard; + } + + /** Last cycle leaderboard error while no snapshot is loaded or within 30s, else {@code ""}. */ + public String recentCycleLeaderboardError() { + if (cycleLeaderboardError.isEmpty()) { + return ""; + } + return (knownCycleLeaderboard == null || System.currentTimeMillis() - cycleLeaderboardErrorAtMs < 30_000L) ? cycleLeaderboardError : ""; + } + + /** Bumped on every cycle leaderboard snapshot or error update. */ + public int cycleLeaderboardGeneration() { + return cycleLeaderboardGeneration.get(); + } + + /** Latest lifetime/interval leaderboard snapshot, or {@code null} before first reply. */ + public tel.eden.mod.net.CycleLeaderboardData.LifetimeSnapshot knownLifetimeLeaderboard() { + return knownLifetimeLeaderboard; + } + + /** Last lifetime leaderboard error while no snapshot is loaded or within 30s, else {@code ""}. */ + public String recentLifetimeLeaderboardError() { + if (lifetimeLeaderboardError.isEmpty()) { + return ""; + } + return (knownLifetimeLeaderboard == null || System.currentTimeMillis() - lifetimeLeaderboardErrorAtMs < 30_000L) ? lifetimeLeaderboardError : ""; + } + + /** Bumped on every lifetime leaderboard snapshot or error update. */ + public int lifetimeLeaderboardGeneration() { + return lifetimeLeaderboardGeneration.get(); + } + /** The guild reward helper (rank lookups + gifting). */ public GuildRewards guildRewards() { return guildRewards; @@ -849,7 +913,7 @@ public void release() { }).then(ClientCommandManager.literal("download").executes(ctx -> { updateDownload(ctx.getSource()); return 1; - }))).then(buildGiftCommand()).then(buildDeductCommand()).then(buildAllyCommand()).then(buildEventCommand()).then(ClientCommandManager.literal("logscan").requires(guildOnly).executes(ctx -> scanLog(ctx.getSource()))).then(ClientCommandManager.literal("dump").requires(guildOnly).then(ClientCommandManager.argument("member", StringArgumentType.word()).suggests(this::suggestMembers).executes(ctx -> dumpEmeralds(ctx.getSource(), StringArgumentType.getString(ctx, "member"))))).then(ClientCommandManager.literal("wars").requires(guildOnly).executes(ctx -> { + }))).then(buildGiftCommand()).then(buildDeductCommand()).then(buildAllyCommand()).then(buildEventCommand()).then(buildCycleCommand()).then(ClientCommandManager.literal("logscan").requires(guildOnly).executes(ctx -> scanLog(ctx.getSource()))).then(ClientCommandManager.literal("dump").requires(guildOnly).then(ClientCommandManager.argument("member", StringArgumentType.word()).suggests(this::suggestMembers).executes(ctx -> dumpEmeralds(ctx.getSource(), StringArgumentType.getString(ctx, "member"))))).then(ClientCommandManager.literal("wars").requires(guildOnly).executes(ctx -> { requestWarCounts(ctx.getSource(), 7); return 1; }).then(ClientCommandManager.argument("days", com.mojang.brigadier.arguments.IntegerArgumentType.integer(1, 365)).executes(ctx -> { @@ -1470,6 +1534,83 @@ public void onLongEventRewards(int pendingLe, String error) { display(() -> DiscordChatFormatter.systemLine("Pending event rewards: " + pendingLe + " LE", ChatFormatting.GOLD)); } + @Override + public void onCycleLeaderboard(tel.eden.mod.net.CycleLeaderboardData.CycleSnapshot snapshot) { + if (!isFullMember()) { + return; + } + if (snapshot.error() != null && !snapshot.error().isEmpty()) { + cycleGuiPendingId.set(0); + cyclePrintPendingId.set(0); + pendingCycleGuiCode = null; + String err = snapshot.error(); + cycleLeaderboardError = err; + cycleLeaderboardErrorAtMs = System.currentTimeMillis(); + cycleLeaderboardGeneration.incrementAndGet(); + if (pendingCyclePrintCode != null) { + pendingCyclePrintCode = null; + display(() -> DiscordChatFormatter.systemLine(err, ChatFormatting.RED)); + } + return; + } + String printTarget = pendingCyclePrintCode; + if (printTarget != null && tel.eden.mod.net.CycleLeaderboardData.matchesRequestedCycle(snapshot, printTarget)) { + pendingCyclePrintCode = null; + cyclePrintPendingId.set(0); + tel.eden.mod.net.CycleLeaderboardData.ConcludedCycleSummary derived = tel.eden.mod.net.CycleLeaderboardData.summaryFromSnapshot(snapshot); + display(() -> DiscordChatFormatter.formatCyclePrint(derived)); + } + String guiTarget = pendingCycleGuiCode; + if (guiTarget == null && cycleGuiPendingId.get() == 0 && knownCycleLeaderboard != null) { + return; + } + if (guiTarget != null && !tel.eden.mod.net.CycleLeaderboardData.matchesRequestedCycle(snapshot, guiTarget)) { + return; + } + cycleGuiPendingId.set(0); + pendingCycleGuiCode = null; + cycleLeaderboardError = ""; + cycleLeaderboardErrorAtMs = 0L; + knownCycleLeaderboard = snapshot; + cycleLeaderboardGeneration.incrementAndGet(); + } + + @Override + public void onLifetimeLeaderboard(tel.eden.mod.net.CycleLeaderboardData.LifetimeSnapshot snapshot) { + if (!isFullMember()) { + return; + } + if (snapshot.error() != null && !snapshot.error().isEmpty()) { + lifetimeRequestPendingId.set(0); + pendingLifetimeFilter = null; + lifetimeLeaderboardError = snapshot.error(); + lifetimeLeaderboardErrorAtMs = System.currentTimeMillis(); + lifetimeLeaderboardGeneration.incrementAndGet(); + return; + } + LifetimeFilter expected = pendingLifetimeFilter; + if (expected != null && !tel.eden.mod.net.CycleLeaderboardData.matchesRequestedInterval(snapshot, expected.fromDays(), expected.toDays())) { + return; + } + lifetimeRequestPendingId.set(0); + pendingLifetimeFilter = null; + lifetimeLeaderboardError = ""; + lifetimeLeaderboardErrorAtMs = 0L; + knownLifetimeLeaderboard = snapshot; + lifetimeLeaderboardGeneration.incrementAndGet(); + } + + @Override + public void onCycleConcluded(tel.eden.mod.net.CycleLeaderboardData.ConcludedCycleSummary summary) { + if (!isFullMember()) { + return; + } + if (summary.cycleCode() != null && !summary.cycleCode().isEmpty()) { + concludedCyclesByCode.put(summary.cycleCode(), summary); + } + display(() -> DiscordChatFormatter.cycleConcluded(summary.cycleCode())); + } + @Override public void onAuthStatus(boolean linked, boolean member, boolean traveler, String guildRank, String discordRank) { handleAuthStatus(linked, member, traveler, guildRank, discordRank); @@ -1832,6 +1973,183 @@ private void requestEventRewards(FabricClientCommandSource source) { }, 5, TimeUnit.SECONDS); } + private LiteralArgumentBuilder buildCycleCommand() { + return ClientCommandManager.literal("cycle").requires(fullMemberOnly).executes(ctx -> openCycleGui(null)).then(ClientCommandManager.literal("view").executes(ctx -> openCycleGui(null)).then(ClientCommandManager.argument("cycle", StringArgumentType.word()).executes(ctx -> openCycleGui(StringArgumentType.getString(ctx, "cycle"))))).then(ClientCommandManager.literal("print").executes(ctx -> printCycleSummary(ctx.getSource(), null)).then(ClientCommandManager.argument("cycle", StringArgumentType.word()).executes(ctx -> printCycleSummary(ctx.getSource(), StringArgumentType.getString(ctx, "cycle"))))); + } + + private int openCycleGui(String cycleCode) { + if (!isFullMember()) { + return 0; + } + Minecraft mc = Minecraft.getInstance(); + mc.execute(() -> mc.setScreen(new tel.eden.mod.gui.PromotionCycleScreen(mc.screen, this, cycleCode))); + return 1; + } + + private int printCycleSummary(FabricClientCommandSource source, String cycleCode) { + if (!isFullMember()) { + return 0; + } + String trimmed = (cycleCode != null && !cycleCode.isBlank()) ? cycleCode.trim() : ""; + tel.eden.mod.net.CycleLeaderboardData.ConcludedCycleSummary cached = !trimmed.isEmpty() ? concludedCyclesByCode.get(trimmed) : null; + if (cached != null) { + source.sendFeedback(DiscordChatFormatter.formatCyclePrint(cached)); + return 1; + } + tel.eden.mod.net.CycleLeaderboardData.CycleSnapshot snap = knownCycleLeaderboard; + if (tel.eden.mod.net.CycleLeaderboardData.isHistoricalCycle(snap, trimmed)) { + source.sendFeedback(DiscordChatFormatter.formatCyclePrint(tel.eden.mod.net.CycleLeaderboardData.summaryFromSnapshot(snap))); + return 1; + } + requestCycleLeaderboard(trimmed, true); + return 1; + } + + /** Request promotion cycle leaderboard data (current if null/blank), debounced safely above server throttle. */ + public void requestCycleLeaderboard(String cycleCode) { + requestCycleLeaderboard(cycleCode, false); + } + + private void requestCycleLeaderboard(String cycleCode, boolean forPrint) { + String target = (cycleCode != null && !cycleCode.isBlank()) ? cycleCode.trim() : ""; + long seq = forPrint ? cyclePrintSeq.incrementAndGet() : cycleGuiSeq.incrementAndGet(); + if (forPrint) { + pendingCyclePrintCode = target; + } else { + pendingCycleGuiCode = target; + } + BridgeWebSocketClient current = socket; + if (!isFullMember() || current == null || !current.isConnected()) { + failCycleLeaderboardRequest(forPrint); + return; + } + long delayMs = knownCycleLeaderboard == null && lastCycleQueryAtMs == 0L ? 0L : Math.max(0L, (lastCycleQueryAtMs + 950L) - System.currentTimeMillis()); + if (delayMs == 0L) { + dispatchCycleLeaderboardRequest(target, seq, forPrint); + return; + } + scheduleCycleLeaderboardDispatch(target, seq, forPrint, delayMs); + } + + private void scheduleCycleLeaderboardDispatch(String cycleCode, long seq, boolean forPrint, long delayMs) { + partyCommandExecutor.schedule(() -> { + long latest = forPrint ? cyclePrintSeq.get() : cycleGuiSeq.get(); + if (latest == seq) { + dispatchCycleLeaderboardRequest(cycleCode, seq, forPrint); + } + }, delayMs, TimeUnit.MILLISECONDS); + } + + private void dispatchCycleLeaderboardRequest(String cycleCode, long seq, boolean forPrint) { + BridgeWebSocketClient current = socket; + if (!isFullMember() || current == null || !current.isConnected()) { + long latest = forPrint ? cyclePrintSeq.get() : cycleGuiSeq.get(); + if (latest == seq) { + failCycleLeaderboardRequest(forPrint); + } + return; + } + long remainingCooldownMs; + synchronized (cycleSendLock) { + long now = System.currentTimeMillis(); + remainingCooldownMs = (lastCycleQueryAtMs + 950L) - now; + if (remainingCooldownMs <= 0L) { + lastCycleQueryAtMs = now; + } + } + if (remainingCooldownMs > 0L) { + scheduleCycleLeaderboardDispatch(cycleCode, seq, forPrint, remainingCooldownMs); + return; + } + java.util.concurrent.atomic.AtomicLong pendingSlot = forPrint ? cyclePrintPendingId : cycleGuiPendingId; + pendingSlot.set(seq); + if (!forPrint) { + cycleLeaderboardError = ""; + cycleLeaderboardErrorAtMs = 0L; + } + if (!current.sendCycleLeaderboardRequest(cycleCode)) { + if (pendingSlot.compareAndSet(seq, 0)) { + failCycleLeaderboardRequest(forPrint); + } + return; + } + partyCommandExecutor.schedule(() -> { + if (pendingSlot.compareAndSet(seq, 0)) { + failCycleLeaderboardRequest(forPrint); + } + }, LEADERBOARD_TIMEOUT_SECONDS, TimeUnit.SECONDS); + } + + private void failCycleLeaderboardRequest(boolean forPrint) { + if (forPrint) { + cyclePrintPendingId.set(0); + if (pendingCyclePrintCode != null) { + pendingCyclePrintCode = null; + display(() -> DiscordChatFormatter.systemLine("Failed to fetch cycle leaderboard", ChatFormatting.RED)); + } + return; + } + cycleGuiPendingId.set(0); + pendingCycleGuiCode = null; + cycleLeaderboardError = "Failed to fetch cycle leaderboard"; + cycleLeaderboardErrorAtMs = System.currentTimeMillis(); + cycleLeaderboardGeneration.incrementAndGet(); + } + + /** Request lifetime or interval Raids/Wars leaderboards, debounced safely above server throttle. */ + public void requestLifetimeLeaderboard(Double fromDays, Double toDays) { + long seq = lifetimeRequestSeq.incrementAndGet(); + pendingLifetimeFilter = new LifetimeFilter(fromDays, toDays); + BridgeWebSocketClient current = socket; + if (!isFullMember() || current == null || !current.isConnected()) { + failLifetimeLeaderboardRequest(); + return; + } + long delayMs = knownLifetimeLeaderboard == null ? 0L : Math.max(0L, (lastLifetimeQueryAtMs + 950L) - System.currentTimeMillis()); + if (delayMs == 0L) { + dispatchLifetimeLeaderboardRequest(fromDays, toDays, seq); + return; + } + partyCommandExecutor.schedule(() -> { + if (lifetimeRequestSeq.get() == seq) { + dispatchLifetimeLeaderboardRequest(fromDays, toDays, seq); + } + }, delayMs, TimeUnit.MILLISECONDS); + } + + private void dispatchLifetimeLeaderboardRequest(Double fromDays, Double toDays, long seq) { + BridgeWebSocketClient current = socket; + if (!isFullMember() || current == null || !current.isConnected()) { + if (lifetimeRequestSeq.get() == seq) { + failLifetimeLeaderboardRequest(); + } + return; + } + lifetimeRequestPendingId.set(seq); + lastLifetimeQueryAtMs = System.currentTimeMillis(); + lifetimeLeaderboardError = ""; + lifetimeLeaderboardErrorAtMs = 0L; + if (!current.sendLifetimeLeaderboardRequest(fromDays, toDays)) { + if (lifetimeRequestPendingId.compareAndSet(seq, 0)) { + failLifetimeLeaderboardRequest(); + } + return; + } + partyCommandExecutor.schedule(() -> { + if (lifetimeRequestPendingId.compareAndSet(seq, 0)) { + failLifetimeLeaderboardRequest(); + } + }, LEADERBOARD_TIMEOUT_SECONDS, TimeUnit.SECONDS); + } + + private void failLifetimeLeaderboardRequest() { + lifetimeRequestPendingId.set(0); + pendingLifetimeFilter = null; + lifetimeLeaderboardError = "Failed to fetch leaderboard stats"; + lifetimeLeaderboardErrorAtMs = System.currentTimeMillis(); + lifetimeLeaderboardGeneration.incrementAndGet(); + } + private CompletableFuture suggestMembers(CommandContext context, SuggestionsBuilder builder) { String remaining = builder.getRemaining().toLowerCase(Locale.ROOT); for (String name : guildRewards.memberNames()) { @@ -2728,9 +3046,9 @@ private int handleTravelerReplyCommand(String messageId) { private record HelpEntry(String command, String description) { } - private static final java.util.Set GUILD_ONLY_COMMANDS = java.util.Set.of("online", "wars", "event", "aspects", "emeralds", "warpay", "rewards", "gift", "dump", "deduct", "ally", "reply", "logscan"); + private static final java.util.Set GUILD_ONLY_COMMANDS = java.util.Set.of("online", "wars", "event", "cycle", "aspects", "emeralds", "warpay", "rewards", "gift", "dump", "deduct", "ally", "reply", "logscan"); - private static final List HELP_ENTRIES = List.of(new HelpEntry("/eden config", "open the config screen"), new HelpEntry("/eden online", "who's connected to the bridge"), new HelpEntry("/eden mail ", "leave a member a message for their next login"), new HelpEntry("/eden cf", "flip a coin"), new HelpEntry("/eden diceroll", "roll a die"), new HelpEntry("/eden tc ", "chat with travelers and members (alias /e)"), new HelpEntry("/eden wars [days]", "guild war counts (same as Discord)"), new HelpEntry("/eden emojis", "open the chat emote picker"), new HelpEntry("/eden event", "open the event missions screen"), new HelpEntry("/eden event rewards", "check your pending event LE"), new HelpEntry("/eden party", "list open parties (click to join)"), new HelpEntry("/eden party create [note]", "open a raid party"), new HelpEntry("/eden party join ", "join a party"), new HelpEntry("/eden party leave [id]", "leave your party"), new HelpEntry("/eden party disband", "disband your hosted party"), new HelpEntry("/eden anni [note]", "open an Annihilation party (2-10)"), new HelpEntry("/eden command alias", "open the command alias editor"), new HelpEntry("/eden command keybind", "open the command keybind editor"), new HelpEntry("/eden update", "check for a pending update"), new HelpEntry("/eden update download", "download the update now (applies on exit)"), new HelpEntry("/eden aspects pending", "members' pending aspects — Chiefs only"), new HelpEntry("/eden gift ", "gift guild rewards — Chiefs only"), new HelpEntry("/eden dump ", "gift all guild-bank emeralds to a member — Chiefs only"), new HelpEntry("/eden deduct ", "deduct a payout from pending rewards — Chiefs only"), new HelpEntry("/eden ally view", "view guild ally activity (most inactive to active)"), new HelpEntry("/eden ally add ", "add a guild ally — Strategist+ only"), new HelpEntry("/eden ally remove ", "remove a guild ally — Strategist+ only"), new HelpEntry("/eden rewards", "check your pending aspects/emeralds/warpay and opt-out status"), new HelpEntry("/eden aspects optout [true|false]", "opt out of or into receiving aspects"), new HelpEntry("/eden emeralds optout [true|false]", "opt out of or into receiving emeralds"), new HelpEntry("/eden warpay optout [true|false]", "opt out of or into receiving warpay"), new HelpEntry("/eden help", "this help screen")); + private static final List HELP_ENTRIES = List.of(new HelpEntry("/eden config", "open the config screen"), new HelpEntry("/eden online", "who's connected to the bridge"), new HelpEntry("/eden mail ", "leave a member a message for their next login"), new HelpEntry("/eden cf", "flip a coin"), new HelpEntry("/eden diceroll", "roll a die"), new HelpEntry("/eden tc ", "chat with travelers and members (alias /e)"), new HelpEntry("/eden wars [days]", "guild war counts (same as Discord)"), new HelpEntry("/eden emojis", "open the chat emote picker"), new HelpEntry("/eden event", "open the event missions screen"), new HelpEntry("/eden event rewards", "check your pending event LE"), new HelpEntry("/eden cycle", "open the promotion cycle leaderboard"), new HelpEntry("/eden party", "list open parties (click to join)"), new HelpEntry("/eden party create [note]", "open a raid party"), new HelpEntry("/eden party join ", "join a party"), new HelpEntry("/eden party leave [id]", "leave your party"), new HelpEntry("/eden party disband", "disband your hosted party"), new HelpEntry("/eden anni [note]", "open an Annihilation party (2-10)"), new HelpEntry("/eden command alias", "open the command alias editor"), new HelpEntry("/eden command keybind", "open the command keybind editor"), new HelpEntry("/eden update", "check for a pending update"), new HelpEntry("/eden update download", "download the update now (applies on exit)"), new HelpEntry("/eden aspects pending", "members' pending aspects — Chiefs only"), new HelpEntry("/eden gift ", "gift guild rewards — Chiefs only"), new HelpEntry("/eden dump ", "gift all guild-bank emeralds to a member — Chiefs only"), new HelpEntry("/eden deduct ", "deduct a payout from pending rewards — Chiefs only"), new HelpEntry("/eden ally view", "view guild ally activity (most inactive to active)"), new HelpEntry("/eden ally add ", "add a guild ally — Strategist+ only"), new HelpEntry("/eden ally remove ", "remove a guild ally — Strategist+ only"), new HelpEntry("/eden rewards", "check your pending aspects/emeralds/warpay and opt-out status"), new HelpEntry("/eden aspects optout [true|false]", "opt out of or into receiving aspects"), new HelpEntry("/eden emeralds optout [true|false]", "opt out of or into receiving emeralds"), new HelpEntry("/eden warpay optout [true|false]", "opt out of or into receiving warpay"), new HelpEntry("/eden help", "this help screen")); private static final class TrackedCommandKeybind { private final String input; @@ -2769,7 +3087,8 @@ private void setDown(boolean down) { private void showHelp(FabricClientCommandSource source) { MutableComponent help = Component.literal("EdenMod — in-game commands:").withStyle(net.minecraft.ChatFormatting.GREEN); for (HelpEntry entry : HELP_ENTRIES) { - if (isTraveler() && GUILD_ONLY_COMMANDS.contains(entry.command().split(" ")[1])) { + String cmd = entry.command().split(" ")[1]; + if (("cycle".equals(cmd) && !isFullMember()) || (isTraveler() && GUILD_ONLY_COMMANDS.contains(cmd))) { continue; } help.append(helpLine(entry.command(), entry.description())); @@ -2993,6 +3312,26 @@ private synchronized void disconnect() { longEventGeneration.set(0); longEventError = ""; longEventErrorAtMs = 0L; + cycleGuiSeq.incrementAndGet(); + cycleGuiPendingId.set(0); + cyclePrintSeq.incrementAndGet(); + cyclePrintPendingId.set(0); + lifetimeRequestSeq.incrementAndGet(); + lifetimeRequestPendingId.set(0); + knownCycleLeaderboard = null; + cycleLeaderboardGeneration.set(0); + cycleLeaderboardError = ""; + cycleLeaderboardErrorAtMs = 0L; + knownLifetimeLeaderboard = null; + lifetimeLeaderboardGeneration.set(0); + lifetimeLeaderboardError = ""; + lifetimeLeaderboardErrorAtMs = 0L; + concludedCyclesByCode.clear(); + pendingCyclePrintCode = null; + pendingCycleGuiCode = null; + pendingLifetimeFilter = null; + lastCycleQueryAtMs = 0L; + lastLifetimeQueryAtMs = 0L; tel.eden.mod.chat.ImagePreviewManager.clear(); // Before the socket goes: an outstanding deduct must not outlive the session that // made it, or it resurfaces at the next connect naming a player from another diff --git a/src/tel/eden/mod/chat/DiscordChatFormatter.java b/src/tel/eden/mod/chat/DiscordChatFormatter.java index 8f07a05..63412d1 100644 --- a/src/tel/eden/mod/chat/DiscordChatFormatter.java +++ b/src/tel/eden/mod/chat/DiscordChatFormatter.java @@ -119,6 +119,51 @@ public static Component updateAvailable(String version, String pageUrl) { return line; } + /** "The promotion cycle has concluded! [Print] [View]" for in-game guild members only. */ + public static Component cycleConcluded(String cycleCode) { + String arg = (cycleCode != null && !cycleCode.isBlank()) ? " " + cycleCode.trim() : ""; + Style print = Style.EMPTY.withColor(ChatFormatting.AQUA).withUnderlined(true).withClickEvent(new ClickEvent.RunCommand("/eden cycle print" + arg)).withHoverEvent(new HoverEvent.ShowText(Component.literal("Print top cycle results to chat"))); + Style view = Style.EMPTY.withColor(ChatFormatting.GREEN).withUnderlined(true).withClickEvent(new ClickEvent.RunCommand("/eden cycle view" + arg)).withHoverEvent(new HoverEvent.ShowText(Component.literal("Open the promotion cycle leaderboard"))); + return Component.empty().append(prefix(SHIELD)).append(Component.literal("The promotion cycle has concluded! ").withStyle(ChatFormatting.GOLD)).append(Component.literal("[Print]").setStyle(print)).append(Component.literal(" ")).append(Component.literal("[View]").setStyle(view)); + } + + /** Format concluded cycle summary (top 3 raids, top 1 wars, top 3 raffle, totals) for [Print]. */ + public static Component formatCyclePrint(tel.eden.mod.net.CycleLeaderboardData.ConcludedCycleSummary summary) { + MutableComponent out = Component.empty().append(prefix(SHIELD)); + String title = (summary.cycleCode() != null && !summary.cycleCode().isBlank()) ? "Promotion Cycle " + summary.cycleCode() + " Results:" : "Promotion Cycle Results:"; + out.append(Component.literal(title).withStyle(ChatFormatting.GOLD, ChatFormatting.BOLD)); + out.append(Component.literal("\n Top 3 Raids:").withStyle(ChatFormatting.AQUA)); + List topRaids = summary.topRaids().stream().filter(e -> e.count() > 0 && e.rank() <= 3).limit(3).toList(); + if (topRaids.isEmpty()) { + out.append(Component.literal("\n None").withStyle(ChatFormatting.GRAY)); + } else { + for (tel.eden.mod.net.CycleLeaderboardData.LeaderboardEntry e : topRaids) { + out.append(Component.literal("\n #" + e.rank() + " " + e.name()).withStyle(ChatFormatting.WHITE)).append(Component.literal(" — " + e.count() + " raids").withStyle(ChatFormatting.GRAY)); + } + } + out.append(Component.literal("\n Top 1 Wars:").withStyle(ChatFormatting.RED)); + List topWars = summary.topWars().stream().filter(e -> e.count() > 0 && e.rank() == 1).limit(3).toList(); + if (topWars.isEmpty()) { + out.append(Component.literal("\n None").withStyle(ChatFormatting.GRAY)); + } else { + for (tel.eden.mod.net.CycleLeaderboardData.LeaderboardEntry e : topWars) { + out.append(Component.literal("\n #" + e.rank() + " " + e.name()).withStyle(ChatFormatting.WHITE)).append(Component.literal(" — " + e.count() + " wars").withStyle(ChatFormatting.GRAY)); + } + } + out.append(Component.literal("\n Top 3 Raffle:").withStyle(ChatFormatting.LIGHT_PURPLE)); + List winners = summary.raffleWinners().subList(0, Math.min(3, summary.raffleWinners().size())); + if (winners.isEmpty()) { + out.append(Component.literal("\n None").withStyle(ChatFormatting.GRAY)); + } else { + for (int i = 0; i < winners.size(); i++) { + tel.eden.mod.net.CycleLeaderboardData.RaffleWinner w = winners.get(i); + out.append(Component.literal("\n #" + (i + 1) + " " + w.name()).withStyle(ChatFormatting.WHITE)).append(Component.literal(" — " + w.tickets() + " tickets (" + w.raids() + " raids)").withStyle(ChatFormatting.GRAY)); + } + } + out.append(Component.literal("\n Totals: ").withStyle(ChatFormatting.GOLD)).append(Component.literal(summary.totalRaids() + " raids | " + summary.totalWars() + " wars | " + summary.totalTickets() + " tickets").withStyle(ChatFormatting.YELLOW)); + return out; + } + /** A green/gold/red client-side notice line with the guild shield prefix. */ public static Component systemLine(String text, ChatFormatting color) { return Component.empty().append(prefix(SHIELD)).append(Component.literal(text).withStyle(color)); diff --git a/src/tel/eden/mod/gui/BridgeConfigScreen.java b/src/tel/eden/mod/gui/BridgeConfigScreen.java index dda7e88..bc6fa21 100644 --- a/src/tel/eden/mod/gui/BridgeConfigScreen.java +++ b/src/tel/eden/mod/gui/BridgeConfigScreen.java @@ -119,6 +119,10 @@ protected void init() { if (!traveler) { addToggleRow(Category.GENERAL, "Discord Bridge Messages", () -> config.discordBridgeMessages, v -> config.discordBridgeMessages = v, "On", "Off", true); } + if (mod.isFullMember()) { + addButtonRow(Category.GENERAL, "Promotion cycle", () -> Component.literal("Open..."), () -> this.minecraft.setScreen(new PromotionCycleScreen(this, mod)), () -> { + }); + } addToggleRow(Category.GENERAL, "Traveler chat", () -> config.travelerChat, v -> { config.travelerChat = v; EdenModClient.syncTravelerPrefs(config); diff --git a/src/tel/eden/mod/gui/EdenMenuScreen.java b/src/tel/eden/mod/gui/EdenMenuScreen.java index 07db757..8f979da 100644 --- a/src/tel/eden/mod/gui/EdenMenuScreen.java +++ b/src/tel/eden/mod/gui/EdenMenuScreen.java @@ -17,9 +17,9 @@ public class EdenMenuScreen extends EdenScreen { private static final int BASE_CONTENT_WIDTH = 200; private static final int BUTTON_HEIGHT = 20; private static final int BUTTON_SPACING = 24; - private static final int BUTTON_COUNT = 8; - // Event and Payouts are guild-only. - private static final int TRAVELER_HIDDEN_BUTTONS = 2; + private static final int BUTTON_COUNT = 9; + // Event, Promotion cycle, and Payouts are hidden from travelers. + private static final int TRAVELER_HIDDEN_BUTTONS = 3; private static final int LOGO_WIDTH = 128; private static final int LOGO_GAP = 20; private static final int CONTENT_MARGIN = 12; @@ -67,6 +67,7 @@ protected void init() { } this.minecraft.setScreen(new LongEventScreen(this, mod)); }).bounds(metrics.buttonX, metrics.startY + (metrics.buttonPitch * slot++), metrics.buttonWidth, metrics.buttonHeight).build()); + this.addRenderableWidget(Button.builder(Component.literal("Promotion cycle"), button -> this.minecraft.setScreen(new PromotionCycleScreen(this, EdenModClient.instance()))).bounds(metrics.buttonX, metrics.startY + (metrics.buttonPitch * slot++), metrics.buttonWidth, metrics.buttonHeight).build()); } this.addRenderableWidget(Button.builder(Component.literal("Create Party"), button -> { @@ -213,8 +214,8 @@ private static boolean isMember() { private static int buttonCount() { int count = isTraveler() ? BUTTON_COUNT - TRAVELER_HIDDEN_BUTTONS : BUTTON_COUNT; - // Event is member-only; a traveler already has it counted in TRAVELER_HIDDEN_BUTTONS. - return !isTraveler() && !isMember() ? count - 1 : count; + // Event and Promotion cycle are full-member-only; observers lack both as well. + return !isTraveler() && !isMember() ? count - 2 : count; } private int bottomSafeMargin() { diff --git a/src/tel/eden/mod/gui/PromotionCycleScreen.java b/src/tel/eden/mod/gui/PromotionCycleScreen.java new file mode 100644 index 0000000..0d8a64e --- /dev/null +++ b/src/tel/eden/mod/gui/PromotionCycleScreen.java @@ -0,0 +1,861 @@ +package tel.eden.mod.gui; + +import java.util.List; +import net.minecraft.ChatFormatting; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.client.gui.components.Button; +import net.minecraft.client.gui.components.EditBox; +import net.minecraft.client.gui.components.PlayerFaceRenderer; +import net.minecraft.client.gui.screens.Screen; +import net.minecraft.client.input.CharacterEvent; +import net.minecraft.client.input.KeyEvent; +import net.minecraft.client.input.MouseButtonEvent; +import net.minecraft.client.renderer.RenderPipelines; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.Identifier; +import net.minecraft.world.entity.player.PlayerSkin; +import tel.eden.mod.EdenModClient; +import tel.eden.mod.net.CycleLeaderboardData; +import tel.eden.mod.util.PlayerSkinResolver; + +/** Promotion Cycle (& Archive) and Lifetime leaderboard screen for full guild members. */ +public class PromotionCycleScreen extends EdenReferenceScreen { + private static final int MARGIN_X = 12; + private static final int COL_GAP = 16; + private static final int SCROLLBAR_GAP = 2; + private static final int SCROLLBAR_WIDTH = 6; + private static final int ROW_PITCH = 17; + private static final int ROW_HEIGHT = 15; + private static final int PODIUM_CAP_WIDTH = 30; + private static final int PODIUM_HEAD_SIZE = 32; + private static final int ZERO_ROW_OVERLAY = 0x44CC2222; + private static final int ROW_FILL = 0x44282828; + + private static final Identifier EDEN_ICON = Identifier.fromNamespaceAndPath("edenmod", "icon.png"); + private static final Identifier[] MEDAL_TEXTURES = {Identifier.fromNamespaceAndPath("edenmod", "textures/gui/cycle/medal_1.png"), Identifier.fromNamespaceAndPath("edenmod", "textures/gui/cycle/medal_2.png"), Identifier.fromNamespaceAndPath("edenmod", "textures/gui/cycle/medal_3.png"),}; + + private enum Tab { + CYCLE, LIFETIME + } + + private final EdenModClient mod; + private final String initialCycleCode; + private EdenPanelLayout layout; + private int closeButtonX = 12; + private int toLabelX = 126; + private int hoveredMouseX; + private int hoveredMouseY; + private String hoveredCutoffText; + + private Tab activeTab = Tab.CYCLE; + private boolean archiveOpen; + private boolean showFinishes; + private boolean initialRequestSent; + private boolean lifetimeRequested; + private String selectedCycleCode; + + private EditBox fromBox; + private EditBox toBox; + private String fromDraft = ""; + private String toDraft = ""; + private String validationError = ""; + + private Button cycleTabButton; + private Button lifetimeTabButton; + private Button archiveButton; + private Button prevCycleButton; + private Button nextCycleButton; + private Button applyIntervalButton; + private Button resetIntervalButton; + private Button finishesToggleButton; + + private int raidsScroll; + private int warsScroll; + private int draggingPane; + private int seenCycleGen = -1; + private int seenLifetimeGen = -1; + + public PromotionCycleScreen(Screen parent, EdenModClient mod) { + this(parent, mod, null); + } + + public PromotionCycleScreen(Screen parent, EdenModClient mod, String initialCycleCode) { + super(Component.literal("Promotion Cycle"), parent); + this.mod = mod; + this.initialCycleCode = (initialCycleCode != null && !initialCycleCode.isBlank()) ? initialCycleCode.trim() : null; + this.selectedCycleCode = this.initialCycleCode; + this.archiveOpen = this.initialCycleCode != null; + } + + @Override + protected void init() { + super.init(); + layout = centeredLayout(560, 320); + + if (fromBox != null) { + fromDraft = fromBox.getValue(); + } + if (toBox != null) { + toDraft = toBox.getValue(); + } + + this.clearWidgets(); + + cycleTabButton = Button.builder(Component.literal("Promotion Cycle"), b -> switchTab(Tab.CYCLE)).bounds(12, 24, 110, 18).build(); + lifetimeTabButton = Button.builder(Component.literal("Lifetime"), b -> switchTab(Tab.LIFETIME)).bounds(126, 24, 80, 18).build(); + this.addRenderableWidget(cycleTabButton); + this.addRenderableWidget(lifetimeTabButton); + + int archiveW = 92; + int nextW = 56; + int prevW = 68; + int archiveX = virtualWidth - 12 - archiveW; + int nextX = archiveX - 4 - nextW; + int prevX = nextX - 4 - prevW; + int closeW = Math.min(100, Math.max(52, prevX - 20)); + closeButtonX = Math.min(Math.max(12, virtualWidth / 2 - closeW / 2), Math.max(12, prevX - closeW - 8)); + int bottomY = virtualHeight - 24; + Button closeButton = Button.builder(Component.literal("Close"), b -> onClose()).bounds(closeButtonX, bottomY, closeW, 18).build(); + this.addRenderableWidget(closeButton); + + // Cycle tab archive controls + prevCycleButton = Button.builder(Component.literal("< Previous"), b -> navigateArchive(-1)).bounds(prevX, bottomY, prevW, 18).build(); + nextCycleButton = Button.builder(Component.literal("Next >"), b -> navigateArchive(1)).bounds(nextX, bottomY, nextW, 18).build(); + archiveButton = Button.builder(Component.literal("Cycle Archive"), b -> toggleArchive()).bounds(archiveX, bottomY, archiveW, 18).build(); + this.addRenderableWidget(prevCycleButton); + this.addRenderableWidget(nextCycleButton); + this.addRenderableWidget(archiveButton); + + // Lifetime tab controls (keep toolbar non-overlapping even on compact viewports) + int finishesW = 106; + int finishesX = virtualWidth - 12 - finishesW; + int boxW = virtualWidth >= 460 ? 78 : Math.max(40, (finishesX - 180) / 2); + int fromX = 42; + toLabelX = fromX + boxW + 6; + int toX = toLabelX + 20; + int applyX = toX + boxW + 6; + int resetX = applyX + 50; + + fromBox = new EditBox(this.font, fromX, 48, boxW, 18, Component.literal("From days ago")); + fromBox.setHint(Component.literal("-# days ago").withStyle(ChatFormatting.GRAY)); + fromBox.setMaxLength(16); + fromBox.setValue(fromDraft); + + toBox = new EditBox(this.font, toX, 48, boxW, 18, Component.literal("To days ago")); + toBox.setHint(Component.literal("-# days ago").withStyle(ChatFormatting.GRAY)); + toBox.setMaxLength(16); + toBox.setValue(toDraft); + + applyIntervalButton = Button.builder(Component.literal("Apply"), b -> applyInterval()).bounds(applyX, 48, 46, 18).build(); + resetIntervalButton = Button.builder(Component.literal("Reset"), b -> resetInterval()).bounds(resetX, 48, 46, 18).build(); + finishesToggleButton = Button.builder(Component.literal("Cycle Finishes"), b -> toggleFinishes()).bounds(finishesX, 48, finishesW, 18).build(); + + this.addRenderableWidget(fromBox); + this.addRenderableWidget(toBox); + this.addRenderableWidget(applyIntervalButton); + this.addRenderableWidget(resetIntervalButton); + this.addRenderableWidget(finishesToggleButton); + + if (!initialRequestSent && mod != null) { + initialRequestSent = true; + seenCycleGen = mod.cycleLeaderboardGeneration(); + seenLifetimeGen = mod.lifetimeLeaderboardGeneration(); + mod.requestCycleLeaderboard(selectedCycleCode); + } + syncControlState(); + } + + @Override + public void tick() { + super.tick(); + if (mod == null) { + return; + } + int cycleGen = mod.cycleLeaderboardGeneration(); + if (seenCycleGen != cycleGen) { + seenCycleGen = cycleGen; + raidsScroll = 0; + warsScroll = 0; + CycleLeaderboardData.CycleSnapshot snap = mod.knownCycleLeaderboard(); + if (!mod.recentCycleLeaderboardError().isEmpty()) { + selectedCycleCode = (snap != null && !snap.cycleCode().isEmpty()) ? snap.cycleCode() : null; + } else if (snap != null && !snap.cycleCode().isEmpty() && snap.error().isEmpty()) { + selectedCycleCode = snap.cycleCode(); + } + syncControlState(); + } + int lifeGen = mod.lifetimeLeaderboardGeneration(); + if (seenLifetimeGen != lifeGen) { + seenLifetimeGen = lifeGen; + raidsScroll = 0; + warsScroll = 0; + syncControlState(); + } + } + + private void switchTab(Tab tab) { + if (activeTab == tab) { + return; + } + activeTab = tab; + raidsScroll = 0; + warsScroll = 0; + validationError = ""; + if (tab == Tab.LIFETIME && !lifetimeRequested && mod != null) { + lifetimeRequested = true; + mod.requestLifetimeLeaderboard(null, null); + } + syncControlState(); + } + + private void toggleArchive() { + archiveOpen = !archiveOpen; + syncControlState(); + } + + private void navigateArchive(int step) { + if (mod == null) { + return; + } + CycleLeaderboardData.CycleSnapshot snap = mod.knownCycleLeaderboard(); + if (snap == null || snap.cycles().isEmpty()) { + return; + } + List cycles = snap.cycles(); + String currentCode = (selectedCycleCode != null && !selectedCycleCode.isEmpty()) ? selectedCycleCode : snap.cycleCode(); + int idx = currentCycleIndex(cycles, currentCode); + if (idx < 0) { + return; + } + int target = idx + step; + if (target >= 0 && target < cycles.size()) { + selectedCycleCode = cycles.get(target); + mod.requestCycleLeaderboard(selectedCycleCode); + syncControlState(); + } + } + + private void applyInterval() { + CycleLeaderboardData.IntervalDays parsed = CycleLeaderboardData.parseIntervalDays(fromBox.getValue(), toBox.getValue()); + if (parsed == null) { + validationError = "Invalid interval: positive days required, From > To"; + return; + } + validationError = ""; + if (mod != null) { + mod.requestLifetimeLeaderboard(parsed.fromDays(), parsed.toDays()); + } + } + + private void resetInterval() { + fromBox.setValue(""); + toBox.setValue(""); + validationError = ""; + if (mod != null) { + mod.requestLifetimeLeaderboard(null, null); + } + } + + private void toggleFinishes() { + showFinishes = !showFinishes; + raidsScroll = 0; + warsScroll = 0; + syncControlState(); + } + + private void syncControlState() { + boolean isCycle = activeTab == Tab.CYCLE; + cycleTabButton.active = !isCycle; + lifetimeTabButton.active = isCycle; + + archiveButton.visible = isCycle; + prevCycleButton.visible = isCycle && archiveOpen; + nextCycleButton.visible = isCycle && archiveOpen; + + if (isCycle && archiveOpen) { + CycleLeaderboardData.CycleSnapshot snap = mod != null ? mod.knownCycleLeaderboard() : null; + List cycles = snap != null ? snap.cycles() : List.of(); + String activeCode = (selectedCycleCode != null && !selectedCycleCode.isEmpty()) ? selectedCycleCode : (snap != null ? snap.cycleCode() : ""); + int idx = currentCycleIndex(cycles, activeCode); + prevCycleButton.active = idx > 0; + nextCycleButton.active = idx >= 0 && idx < cycles.size() - 1; + } else { + prevCycleButton.active = false; + nextCycleButton.active = false; + } + + fromBox.visible = !isCycle; + toBox.visible = !isCycle; + applyIntervalButton.visible = !isCycle; + resetIntervalButton.visible = !isCycle; + finishesToggleButton.visible = !isCycle; + finishesToggleButton.setMessage(Component.literal(showFinishes ? "Counts View" : "Cycle Finishes")); + } + + private int currentCycleIndex(List cycles, String activeCode) { + if (cycles == null || cycles.isEmpty()) { + return -1; + } + String code = (activeCode != null && !activeCode.isEmpty()) ? activeCode : selectedCycleCode; + if (code == null || code.isEmpty()) { + return cycles.size() - 1; + } + return cycles.indexOf(code); + } + + @Override + public void render(GuiGraphics g, int mouseX, int mouseY, float delta) { + int scaledMouseX = scaledMouseX(mouseX); + int scaledMouseY = scaledMouseY(mouseY); + hoveredMouseX = scaledMouseX; + hoveredMouseY = scaledMouseY; + hoveredCutoffText = null; + + pushReferencePose(g); + EdenPanelLayout.drawPanel(g, 0, 0, virtualWidth, virtualHeight); + + if (activeTab == Tab.CYCLE) { + renderCycleTab(g); + } else { + renderLifetimeTab(g); + } + + super.render(g, scaledMouseX, scaledMouseY, delta); + String heading = activeTab == Tab.CYCLE ? "Promotion Cycle" : "Lifetime Stats"; + g.drawCenteredString(this.font, heading, virtualWidth / 2, 10, 0xFFFFFFFF); + popReferencePose(g); + + if (hoveredCutoffText != null) { + int tipWidth = Math.max(140, Math.min(280, this.width - 24)); + g.setTooltipForNextFrame(this.font, this.font.split(Component.literal(hoveredCutoffText), tipWidth), mouseX, mouseY); + } + } + + private void renderCycleTab(GuiGraphics g) { + CycleLeaderboardData.CycleSnapshot snap = mod != null ? mod.knownCycleLeaderboard() : null; + String err = mod != null ? mod.recentCycleLeaderboardError() : ""; + + String cycleHeader = (snap != null && !snap.cycleCode().isEmpty()) ? "Cycle " + snap.cycleCode() : "Loading..."; + String trimmedHeader = trimToWidth(cycleHeader, Math.max(40, virtualWidth - 232)); + drawTrimmedWithHover(g, cycleHeader, 220, 29, Math.max(40, virtualWidth - 232), 0xFFFFCC55); + if (snap != null && CycleLeaderboardData.countsPartyFinderRaids(snap.cycleCode())) { + int warnX = 220 + this.font.width(trimmedHeader) + 6; + int availW = virtualWidth - 12 - warnX; + if (availW >= 40) { + String warn = "ALL CYCLES BEFORE 2503B COUNTED BOTH PARTY FINDER AND GUILD RAIDS"; + float scale = Math.min(1.0f, availW / (float) Math.max(1, this.font.width(warn))); + int yOffset = Math.round(4.5f * (1.0f - scale)); + g.pose().pushMatrix(); + g.pose().translate(warnX, 29 + yOffset); + g.pose().scale(scale, scale); + g.drawString(this.font, warn, 0, 0, 0xFFFF5555); + g.pose().popMatrix(); + } + } + + if (!err.isEmpty()) { + g.drawCenteredString(this.font, err, virtualWidth / 2, virtualHeight / 2, 0xFFFF5555); + return; + } + if (snap == null) { + g.drawCenteredString(this.font, "Loading cycle leaderboard...", virtualWidth / 2, virtualHeight / 2, 0xFFAAAAAA); + return; + } + + String endsText = CycleLeaderboardData.cycleEndText(snap, System.currentTimeMillis()); + if (!endsText.isEmpty()) { + int headingRight = virtualWidth / 2 + this.font.width("Promotion Cycle") / 2 + 8; + int maxTimerW = virtualWidth - 12 - headingRight; + if (maxTimerW >= 40) { + int textW = Math.min(maxTimerW, this.font.width(endsText)); + int timerX = Math.max(headingRight, virtualWidth - 12 - textW); + int timerColor = endsText.startsWith("Ends in ") ? 0xFFCCCCCC : 0xFFAAAAAA; + drawTrimmedWithHover(g, endsText, timerX, 10, maxTimerW, timerColor); + } + } + + int colW = colWidth(); + int titleY = titleY(); + g.drawCenteredString(this.font, "Raids", colX(true) + colW / 2, titleY, 0xFF55FFFF); + g.drawCenteredString(this.font, "Wars", colX(false) + colW / 2, titleY, 0xFFFF5555); + + renderEntryList(g, true, snap.raids(), raidsScroll, true, true); + renderEntryList(g, false, snap.wars(), warsScroll, true, true); + + String totals = "Totals: " + snap.totalRaids() + " raids | " + snap.totalWars() + " wars | " + snap.totalTickets() + " tickets"; + drawTrimmedWithHover(g, totals, 12, virtualHeight - 36, Math.max(60, virtualWidth - 24), 0xFFFFD966); + if (!snap.raffleWinners().isEmpty()) { + StringBuilder raffle = new StringBuilder("Raffle Top 3: "); + List top = snap.raffleWinners().subList(0, Math.min(3, snap.raffleWinners().size())); + for (int i = 0; i < top.size(); i++) { + if (i > 0) { + raffle.append(", "); + } + raffle.append("#").append(i + 1).append(" ").append(top.get(i).name()).append(" (").append(top.get(i).tickets()).append(")"); + } + int raffleMaxW = Math.max(40, closeButtonX - 20); + drawTrimmedWithHover(g, raffle.toString(), 12, virtualHeight - 24, raffleMaxW, 0xFFD5A6FF); + } + } + + private void renderLifetimeTab(GuiGraphics g) { + g.drawString(this.font, "From:", 12, 53, 0xFFCCCCCC); + g.drawString(this.font, "To:", toLabelX, 53, 0xFFCCCCCC); + if (!validationError.isEmpty()) { + drawTrimmedWithHover(g, validationError, 12, virtualHeight - 36, Math.max(60, virtualWidth - 24), 0xFFFF5555); + } + + CycleLeaderboardData.LifetimeSnapshot snap = mod != null ? mod.knownLifetimeLeaderboard() : null; + String err = mod != null ? mod.recentLifetimeLeaderboardError() : ""; + if (!err.isEmpty()) { + g.drawCenteredString(this.font, err, virtualWidth / 2, virtualHeight / 2 + 12, 0xFFFF5555); + return; + } + if (snap == null) { + g.drawCenteredString(this.font, "Loading leaderboard stats...", virtualWidth / 2, virtualHeight / 2 + 12, 0xFFAAAAAA); + return; + } + + int colW = colWidth(); + int titleY = titleY(); + int leftCenter = colX(true) + colW / 2; + int rightCenter = colX(false) + colW / 2; + + if (showFinishes) { + g.drawCenteredString(this.font, "Raids Finishes", leftCenter, titleY, 0xFF55FFFF); + g.drawCenteredString(this.font, "Wars Finishes", rightCenter, titleY, 0xFFFF5555); + renderPodiumList(g, true, snap.raidFinishes(), raidsScroll); + renderPodiumList(g, false, snap.warFinishes(), warsScroll); + return; + } + + String subtitle = snap.hasInterval() ? " (Filtered: no medals)" : ""; + g.drawCenteredString(this.font, "Raids" + subtitle, leftCenter, titleY, 0xFF55FFFF); + g.drawCenteredString(this.font, "Wars" + subtitle, rightCenter, titleY, 0xFFFF5555); + + boolean showMedals = !snap.hasInterval(); + renderEntryList(g, true, snap.raids(), raidsScroll, showMedals, false); + renderEntryList(g, false, snap.wars(), warsScroll, showMedals, false); + } + + private void renderPodium(GuiGraphics g, int x, int colW, List rawEntries) { + int podiumTop = podiumTop(); + int podiumH = podiumHeight(); + g.fill(x, podiumTop, x + colW, podiumTop + podiumH, 0x22000000); + g.enableScissor(x, podiumTop, x + colW, podiumTop + podiumH); + + int slotW = Math.clamp(colW / 3 - 4, 34, 96); + int capW = Math.min(PODIUM_CAP_WIDTH, Math.max(18, slotW - 8)); + int headSize = Math.min(podiumH >= 118 ? PODIUM_HEAD_SIZE : 24, Math.max(16, slotW - 8)); + int cx1 = x + colW / 2; + int cx2 = cx1 - slotW; + int cx3 = cx1 + slotW; + int maxStandH = Math.max(24, podiumH - (headSize + 20)); + int h2 = Math.max(20, maxStandH * 76 / 100); + int h3 = Math.max(16, maxStandH * 56 / 100); + int baseLineY = podiumTop + podiumH - 4; + int lineLeft = Math.max(x + 4, cx2 - capW / 2 - 8); + int lineRight = Math.min(x + colW - 4, cx3 + capW / 2 + 8); + g.fill(lineLeft, baseLineY, lineRight, baseLineY + 2, 0xFF8E8E8E); + g.fill(lineLeft, baseLineY + 2, lineRight, baseLineY + 3, 0xFF1E1E1E); + + for (int slot = 0; slot < 3; slot++) { + int rank = slot == 0 ? 2 : (slot == 1 ? 1 : 3); + int cx = slot == 0 ? cx2 : (slot == 1 ? cx1 : cx3); + int standH = slot == 0 ? h2 : (slot == 1 ? maxStandH : h3); + int standTopY = baseLineY - standH; + drawPillar(g, cx, baseLineY, capW, standH); + + int entryIdx = rank - 1; + if (entryIdx >= rawEntries.size()) { + continue; + } + String uuid = null; + String name = null; + String suffix = null; + Object item = rawEntries.get(entryIdx); + if (item instanceof CycleLeaderboardData.LeaderboardEntry e) { + if (e.count() <= 0) { + continue; + } + uuid = e.uuid(); + name = e.name(); + suffix = " (" + e.count() + ")"; + } else if (item instanceof CycleLeaderboardData.PodiumEntry p) { + uuid = p.uuid(); + name = p.name(); + suffix = " (" + p.first() + "/" + p.second() + "/" + p.third() + ")"; + } + if (name == null) { + continue; + } + + int headStartX = cx - headSize / 2; + int headY = standTopY - headSize - 2; + drawPlayerFace(g, uuid, name, headStartX, headY, headSize); + + int halfBound = switch (rank) { + case 2 -> Math.min(cx - x - 3, slotW - headSize / 2 - 3); + case 3 -> Math.min((x + colW) - cx - 3, slotW - headSize / 2 - 3); + default -> Math.min(colW / 2 - 4, (slotW + 28) / 2); + }; + int maxLabelW = Math.max(24, halfBound * 2); + int maxNameW = Math.max(12, maxLabelW - this.font.width(suffix)); + String trimmedName = trimToWidth(name, maxNameW); + String label = trimmedName + suffix; + int labelY = standTopY - headSize - 12; + g.drawCenteredString(this.font, label, cx, labelY, 0xFFFFFFFF); + if (!trimmedName.equals(name)) { + int labelW = this.font.width(label); + int labelLeft = cx - labelW / 2; + recordCutoffHover(name + suffix, labelLeft, labelY, labelW); + } + } + g.disableScissor(); + } + + private void renderEntryList(GuiGraphics g, boolean left, List entries, int scrollOffset, boolean showMedals, boolean showDelta) { + int x = colX(left); + int colW = colWidth(); + renderPodium(g, x, colW, entries); + + int baseTopY = listTopOffset(); + int visRows = visibleRows(); + int height = visRows * ROW_PITCH + 4; + g.fill(x, baseTopY, x + colW, baseTopY + height, 0x22000000); + g.enableScissor(x, baseTopY, x + colW, baseTopY + height); + + int total = entries.size(); + int clamped = clampOffset(scrollOffset, total); + for (int vis = 0; vis < visRows; vis++) { + int idx = clamped + vis; + if (idx >= total) { + break; + } + CycleLeaderboardData.LeaderboardEntry entry = entries.get(idx); + int rowY = baseTopY + 2 + vis * ROW_PITCH; + g.fill(x + 2, rowY, x + colW - 2, rowY + ROW_HEIGHT, entry.count() <= 0 ? ZERO_ROW_OVERLAY : ROW_FILL); + + int cursorX = x + 4; + if (showDelta) { + Integer deltaVal = entry.delta(); + String deltaText = deltaVal == null || deltaVal == 0 ? "-" : (deltaVal > 0 ? "+" + deltaVal : String.valueOf(deltaVal)); + int deltaColor = deltaVal == null || deltaVal == 0 ? 0xFF888888 : (deltaVal > 0 ? 0xFF55FF55 : 0xFFFF5555); + g.drawString(this.font, deltaText, cursorX, rowY + 4, deltaColor); + cursorX += Math.max(22, this.font.width(deltaText) + 4); + } + + drawPlayerFace(g, entry.uuid(), entry.name(), cursorX, rowY + 2, 10); + cursorX += 13; + + int rankColor = switch (entry.rank()) { + case 1 -> 0xFFFFD700; + case 2 -> 0xFFC0C0C0; + case 3 -> 0xFFCD7F32; + default -> 0xFFAAAAAA; + }; + String rankStr = "#" + entry.rank(); + g.drawString(this.font, rankStr, cursorX, rowY + 4, entry.count() <= 0 ? 0xFFCCCCCC : rankColor); + cursorX += Math.max(28, this.font.width(rankStr) + 4); + + int medal = CycleLeaderboardData.medalForEntry(entry, showMedals); + if (medal >= 1 && medal <= 3) { + drawTexture(g, MEDAL_TEXTURES[medal - 1], cursorX, rowY + 2, 11, 11); + cursorX += 13; + } + + String countText = String.valueOf(entry.count()); + int countWidth = this.font.width(countText); + int countX = x + colW - 6 - countWidth; + int maxNameW = Math.max(24, countX - cursorX - 4); + int textColor = entry.count() <= 0 ? 0xFFDDDDDD : 0xFFFFFFFF; + drawTrimmedWithHover(g, entry.name(), cursorX, rowY + 4, maxNameW, textColor); + g.drawString(this.font, countText, countX, rowY + 4, textColor); + } + g.disableScissor(); + + layout.drawScrollbar(g, x + colW + SCROLLBAR_GAP, baseTopY, SCROLLBAR_WIDTH, height, visRows, total, clamped); + } + + private void renderPodiumList(GuiGraphics g, boolean left, List entries, int scrollOffset) { + int x = colX(left); + int colW = colWidth(); + renderPodium(g, x, colW, entries); + + int baseTopY = listTopOffset(); + int visRows = visibleRows(); + int height = visRows * ROW_PITCH + 4; + g.fill(x, baseTopY, x + colW, baseTopY + height, 0x22000000); + g.enableScissor(x, baseTopY, x + colW, baseTopY + height); + + int total = entries.size(); + int clamped = clampOffset(scrollOffset, total); + for (int vis = 0; vis < visRows; vis++) { + int idx = clamped + vis; + if (idx >= total) { + break; + } + CycleLeaderboardData.PodiumEntry entry = entries.get(idx); + int rowY = baseTopY + 2 + vis * ROW_PITCH; + g.fill(x + 2, rowY, x + colW - 2, rowY + ROW_HEIGHT, ROW_FILL); + + int cursorX = x + 4; + drawPlayerFace(g, entry.uuid(), entry.name(), cursorX, rowY + 2, 10); + cursorX += 13; + + int statsStart = x + colW - 88; + int maxNameW = Math.max(24, statsStart - cursorX - 4); + drawTrimmedWithHover(g, entry.name(), cursorX, rowY + 4, maxNameW, 0xFFFFFFFF); + + int[] counts = {entry.first(), entry.second(), entry.third()}; + for (int m = 0; m < 3; m++) { + int slotX = statsStart + m * 28; + drawTexture(g, MEDAL_TEXTURES[m], slotX, rowY + 3, 9, 9); + g.drawString(this.font, String.valueOf(counts[m]), slotX + 11, rowY + 4, 0xFFEFEFEF); + } + } + g.disableScissor(); + + layout.drawScrollbar(g, x + colW + SCROLLBAR_GAP, baseTopY, SCROLLBAR_WIDTH, height, visRows, total, clamped); + } + + private void drawPlayerFace(GuiGraphics g, String uuid, String name, int x, int y, int size) { + if (this.minecraft == null) { + return; + } + PlayerSkin skin = PlayerSkinResolver.skinForId(this.minecraft, uuid, name); + if (skin != null) { + PlayerFaceRenderer.draw(g, skin, x, y, size); + } + } + + private int totalColWidth() { + return Math.max(96, (virtualWidth - MARGIN_X * 2 - COL_GAP) / 2); + } + + private int colWidth() { + return totalColWidth() - SCROLLBAR_GAP - SCROLLBAR_WIDTH; + } + + private int colX(boolean left) { + return left ? MARGIN_X : (MARGIN_X + totalColWidth() + COL_GAP); + } + + private int titleY() { + return activeTab == Tab.CYCLE ? 46 : 70; + } + + private int podiumTop() { + return titleY() + 11; + } + + private int footerReserve() { + return (activeTab == Tab.CYCLE || !validationError.isEmpty()) ? 42 : 30; + } + + private int availableBodyHeight() { + return Math.max(40, virtualHeight - footerReserve() - podiumTop() - 4); + } + + private int podiumHeight() { + int avail = availableBodyHeight(); + int minRows = avail >= 140 ? 3 : 2; + int maxPodium = Math.max(60, avail - (minRows * ROW_PITCH + 4)); + return Math.min(maxPodium, Math.clamp(avail * 56 / 100, 96, 184)); + } + + private int listTopOffset() { + return podiumTop() + podiumHeight() + 4; + } + + private int visibleRows() { + int listAvail = Math.max(ROW_PITCH + 4, availableBodyHeight() - podiumHeight()); + return Math.max(1, (listAvail - 4) / ROW_PITCH); + } + + private List leftEntries() { + if (mod == null) { + return List.of(); + } + if (activeTab == Tab.CYCLE) { + CycleLeaderboardData.CycleSnapshot snap = mod.knownCycleLeaderboard(); + return snap != null ? snap.raids() : List.of(); + } + CycleLeaderboardData.LifetimeSnapshot snap = mod.knownLifetimeLeaderboard(); + if (snap == null) { + return List.of(); + } + return showFinishes ? snap.raidFinishes() : snap.raids(); + } + + private List rightEntries() { + if (mod == null) { + return List.of(); + } + if (activeTab == Tab.CYCLE) { + CycleLeaderboardData.CycleSnapshot snap = mod.knownCycleLeaderboard(); + return snap != null ? snap.wars() : List.of(); + } + CycleLeaderboardData.LifetimeSnapshot snap = mod.knownLifetimeLeaderboard(); + if (snap == null) { + return List.of(); + } + return showFinishes ? snap.warFinishes() : snap.wars(); + } + + private int clampOffset(int offset, int total) { + int max = Math.max(0, total - visibleRows()); + return Math.clamp(offset, 0, max); + } + + private String trimToWidth(String text, int width) { + if (this.font.width(text) <= width) { + return text; + } + return this.font.plainSubstrByWidth(text, Math.max(0, width - this.font.width("..."))) + "..."; + } + + private void drawTrimmedWithHover(GuiGraphics g, String fullText, int x, int y, int maxWidth, int color) { + String shown = trimToWidth(fullText, maxWidth); + g.drawString(this.font, shown, x, y, color); + if (!shown.equals(fullText)) { + recordCutoffHover(fullText, x, y, this.font.width(shown)); + } + } + + private void recordCutoffHover(String fullText, int x, int y, int width) { + if (hoveredMouseX >= x && hoveredMouseX <= x + width && hoveredMouseY >= y - 1 && hoveredMouseY <= y + this.font.lineHeight) { + hoveredCutoffText = fullText; + } + } + + private static void drawPillar(GuiGraphics g, int centerX, int baseLineY, int capW, int standH) { + int evenCapW = capW & ~1; + int clampedH = Math.max(24, standH); + int capH = Math.min(clampedH - 6, Math.max(14, Math.round(evenCapW * 41f / 45f))); + int shaftW = Math.max(16, Math.round(evenCapW * 31f / 45f)) & ~1; + int shaftH = Math.max(4, clampedH - capH); + int standTopY = baseLineY - clampedH; + + g.blit(RenderPipelines.GUI_TEXTURED, EDEN_ICON, centerX - evenCapW / 2, standTopY, 18.0f, 13.0f, evenCapW, capH, 45, 41, 256, 256); + int segMaxH = Math.max(12, Math.round(60f * evenCapW / 45f)); + int drawn = 0; + while (drawn < shaftH) { + int segH = Math.min(shaftH - drawn, segMaxH); + int srcH = Math.clamp(Math.round(segH * 45f / evenCapW), 1, 60); + g.blit(RenderPipelines.GUI_TEXTURED, EDEN_ICON, centerX - shaftW / 2, standTopY + capH + drawn, 25.0f, 54.0f, shaftW, segH, 31, srcH, 256, 256); + drawn += segH; + } + g.fill(centerX - shaftW / 2 - 2, baseLineY - 2, centerX - shaftW / 2 + shaftW + 2, baseLineY - 1, 0xFF9E8FB2); + g.fill(centerX - shaftW / 2 - 2, baseLineY - 1, centerX - shaftW / 2 + shaftW + 2, baseLineY, 0xFF231F20); + } + + private static void drawTexture(GuiGraphics g, Identifier id, int x, int y, int w, int h) { + if (id == null || w <= 0 || h <= 0) { + return; + } + g.pose().pushMatrix(); + g.pose().translate(x, y); + g.pose().scale(w / 64.0f, h / 64.0f); + g.blit(RenderPipelines.GUI_TEXTURED, id, 0, 0, 0.0f, 0.0f, 64, 64, 64, 64); + g.pose().popMatrix(); + } + + private boolean isInPane(double scaledX, double scaledY, boolean leftPane) { + int left = colX(leftPane); + int bottom = listTopOffset() + visibleRows() * ROW_PITCH + 4; + return scaledX >= left && scaledX <= left + totalColWidth() + 4 && scaledY >= podiumTop() && scaledY <= bottom; + } + + private boolean isOverScrollbar(double scaledX, double scaledY, boolean leftPane) { + int sbX = colX(leftPane) + colWidth() + SCROLLBAR_GAP; + int top = listTopOffset(); + int bottom = top + visibleRows() * ROW_PITCH + 4; + return scaledX >= sbX - 2 && scaledX <= sbX + SCROLLBAR_WIDTH + 2 && scaledY >= top && scaledY <= bottom; + } + + private void updateScrollFromMouse(double scaledY, int pane) { + int top = listTopOffset(); + int visRows = visibleRows(); + int height = visRows * ROW_PITCH + 4; + int total = pane == 1 ? leftEntries().size() : rightEntries().size(); + int maxOffset = Math.max(0, total - visRows); + float ratio = Math.clamp((float) ((scaledY - top) / Math.max(1, height)), 0.0f, 1.0f); + int target = Math.round(ratio * maxOffset); + if (pane == 1) { + raidsScroll = target; + } else { + warsScroll = target; + } + } + + @Override + public boolean mouseClicked(MouseButtonEvent event, boolean doubleClick) { + MouseButtonEvent scaled = rescale(event); + if (scaled.button() == 0) { + if (isOverScrollbar(scaled.x(), scaled.y(), true)) { + draggingPane = 1; + updateScrollFromMouse(scaled.y(), 1); + return true; + } + if (isOverScrollbar(scaled.x(), scaled.y(), false)) { + draggingPane = 2; + updateScrollFromMouse(scaled.y(), 2); + return true; + } + } + return super.mouseClicked(scaled, doubleClick); + } + + @Override + public boolean mouseReleased(MouseButtonEvent event) { + draggingPane = 0; + return super.mouseReleased(rescale(event)); + } + + @Override + public boolean mouseDragged(MouseButtonEvent event, double d, double e) { + MouseButtonEvent scaled = rescale(event); + if (draggingPane != 0) { + updateScrollFromMouse(scaled.y(), draggingPane); + return true; + } + return super.mouseDragged(scaled, d / uiScale, e / uiScale); + } + + @Override + public boolean mouseScrolled(double mouseX, double mouseY, double scrollX, double scrollY) { + double sx = mouseX / uiScale; + double sy = mouseY / uiScale; + int step = scrollY > 0 ? -1 : 1; + if (isInPane(sx, sy, true)) { + raidsScroll = clampOffset(raidsScroll + step, leftEntries().size()); + return true; + } + if (isInPane(sx, sy, false)) { + warsScroll = clampOffset(warsScroll + step, rightEntries().size()); + return true; + } + return super.mouseScrolled(sx, sy, scrollX, scrollY); + } + + @Override + public boolean keyPressed(KeyEvent event) { + if (activeTab == Tab.LIFETIME) { + if (fromBox.keyPressed(event) || toBox.keyPressed(event)) { + return true; + } + } + return super.keyPressed(event); + } + + @Override + public boolean charTyped(CharacterEvent event) { + if (activeTab == Tab.LIFETIME) { + if (fromBox.charTyped(event) || toBox.charTyped(event)) { + return true; + } + } + return super.charTyped(event); + } +} diff --git a/src/tel/eden/mod/net/BridgeWebSocketClient.java b/src/tel/eden/mod/net/BridgeWebSocketClient.java index e9b93c5..2438d16 100644 --- a/src/tel/eden/mod/net/BridgeWebSocketClient.java +++ b/src/tel/eden/mod/net/BridgeWebSocketClient.java @@ -222,6 +222,18 @@ default void onLongEventRewards(int pendingLe, String error) { /** A traveler-chat line from the game or Discord side. */ default void onTravelerChat(String author, String content, String source, String color, String replyTo, String replyExcerpt, String messageId) { } + + /** Promotion cycle leaderboard snapshot (current or archived cycle). */ + default void onCycleLeaderboard(CycleLeaderboardData.CycleSnapshot snapshot) { + } + + /** Lifetime or custom-interval leaderboard snapshot with cycle podium finishes. */ + default void onLifetimeLeaderboard(CycleLeaderboardData.LifetimeSnapshot snapshot) { + } + + /** Broadcast sent when a promotion cycle finishes and finalizes. */ + default void onCycleConcluded(CycleLeaderboardData.ConcludedCycleSummary summary) { + } } /** @@ -1066,6 +1078,37 @@ public void sendLongEventStateRequest() { sendType("longEventStateRequest"); } + /** Request a promotion-cycle leaderboard snapshot (null/blank means current cycle). */ + public boolean sendCycleLeaderboardRequest(String cycleCode) { + WebSocket current = socket; + if (current == null) { + return false; + } + JsonObject obj = new JsonObject(); + obj.addProperty("type", "cycleLeaderboardRequest"); + if (cycleCode != null && !cycleCode.isBlank()) { + obj.addProperty("cycleCode", cycleCode.trim()); + } + return enqueueSend(current, obj); + } + + /** Request lifetime (or custom day-interval) Raids/Wars leaderboards and cycle finishes. */ + public boolean sendLifetimeLeaderboardRequest(Double fromDays, Double toDays) { + WebSocket current = socket; + if (current == null) { + return false; + } + JsonObject obj = new JsonObject(); + obj.addProperty("type", "lifetimeLeaderboardRequest"); + if (fromDays != null) { + obj.addProperty("fromDays", fromDays); + } + if (toDays != null) { + obj.addProperty("toDays", toDays); + } + return enqueueSend(current, obj); + } + /** Ask the backend to reroll a long-event mission slot ({@code "daily"}, {@code "weekly"}, or {@code "repeatable"}). */ public void sendLongEventReroll(String slot) { sendLongEventReroll(slot, false); @@ -1527,10 +1570,11 @@ public void onError(WebSocket webSocket, Throwable error) { private void handlePayload(String payload) { try { JsonObject obj = JsonParser.parseString(payload).getAsJsonObject(); - if (!OutboundPolicy.inboundAllowed(standing, get(obj, "type"))) { + String inboundType = get(obj, "type"); + if (!OutboundPolicy.inboundAllowed(standing, inboundType)) { return; } - switch (get(obj, "type")) { + switch (inboundType) { case "discordMessage" -> sink.onDiscordMessage(get(obj, "author"), get(obj, "content"), get(obj, "replyTo"), get(obj, "replyExcerpt"), get(obj, "color"), get(obj, "messageId")); case "travelerChat" -> sink.onTravelerChat(cap(get(obj, "author"), 64), cap(get(obj, "content"), 512), get(obj, "source"), get(obj, "color"), cap(get(obj, "replyTo"), 64), cap(get(obj, "replyExcerpt"), 256), get(obj, "messageId").matches("[0-9]{1,20}") ? get(obj, "messageId") : ""); case "loginNotice" -> sink.onLoginNotice(get(obj, "username"), get(obj, "color")); @@ -1573,6 +1617,9 @@ private void handlePayload(String payload) { sink.onLongEventState(state, state.isSnapshot()); } case "longEventRewards" -> sink.onLongEventRewards(getInt(obj, "pendingLe", 0), get(obj, "error")); + case "cycleLeaderboardReply" -> sink.onCycleLeaderboard(parseCycleSnapshot(obj)); + case "lifetimeLeaderboardReply" -> sink.onLifetimeLeaderboard(parseLifetimeSnapshot(obj)); + case "cycleConcluded" -> sink.onCycleConcluded(parseConcludedCycleSummary(obj)); case "authChallenge" -> handleAuthChallenge(get(obj, "serverId")); case "authOk" -> { authenticated = true; @@ -1926,4 +1973,79 @@ static LongEventState parseLongEventState(JsonObject obj) { } return new LongEventState(getBool(obj, "active"), getLong(obj, "endsAtMs", 0L), getInt(obj, "pendingLe", 0), getInt(obj, "rerollCost", 0), getInt(obj, "triviaPoints", 0), getBool(obj, "repeatSlot2Active"), get(obj, "error"), slots, masters, specialSlots); } + + private static Integer getOptionalInt(JsonObject obj, String key) { + try { + return obj.has(key) && !obj.get(key).isJsonNull() ? obj.get(key).getAsInt() : null; + } catch (RuntimeException e) { + return null; + } + } + + private static Double getOptionalDouble(JsonObject obj, String key) { + try { + return obj.has(key) && !obj.get(key).isJsonNull() ? obj.get(key).getAsDouble() : null; + } catch (RuntimeException e) { + return null; + } + } + + private static java.util.List parseLeaderboardEntries(JsonObject obj, String key) { + java.util.List out = new java.util.ArrayList<>(); + if (obj.has(key) && obj.get(key).isJsonArray()) { + for (var element : obj.get(key).getAsJsonArray()) { + if (element.isJsonObject()) { + JsonObject row = element.getAsJsonObject(); + out.add(new CycleLeaderboardData.LeaderboardEntry(get(row, "uuid"), get(row, "name"), getInt(row, "count", 0), getInt(row, "rank", 0), getOptionalInt(row, "delta"))); + } + } + } + return CycleLeaderboardData.rankEntries(out); + } + + private static java.util.List parsePodiumEntries(JsonObject obj, String key) { + java.util.List out = new java.util.ArrayList<>(); + if (obj.has(key) && obj.get(key).isJsonArray()) { + for (var element : obj.get(key).getAsJsonArray()) { + if (element.isJsonObject()) { + JsonObject row = element.getAsJsonObject(); + out.add(new CycleLeaderboardData.PodiumEntry(get(row, "uuid"), get(row, "name"), getInt(row, "first", 0), getInt(row, "second", 0), getInt(row, "third", 0))); + } + } + } + return java.util.List.copyOf(out); + } + + private static java.util.List parseRaffleWinners(JsonObject obj) { + java.util.List out = new java.util.ArrayList<>(); + if (obj.has("raffleWinners") && obj.get("raffleWinners").isJsonArray()) { + for (var element : obj.get("raffleWinners").getAsJsonArray()) { + if (element.isJsonObject() && out.size() < 3) { + JsonObject row = element.getAsJsonObject(); + out.add(new CycleLeaderboardData.RaffleWinner(get(row, "name"), getInt(row, "tickets", 0), getInt(row, "raids", 0))); + } + } + } + return java.util.List.copyOf(out); + } + + static CycleLeaderboardData.CycleSnapshot parseCycleSnapshot(JsonObject obj) { + String error = obj.has("error") && !obj.get("error").isJsonNull() ? get(obj, "error") : ""; + if (!error.isEmpty()) { + return CycleLeaderboardData.CycleSnapshot.error(error); + } + return new CycleLeaderboardData.CycleSnapshot(get(obj, "cycleCode"), getStringArray(obj, "cycles"), parseLeaderboardEntries(obj, "raids"), parseLeaderboardEntries(obj, "wars"), parseRaffleWinners(obj), getInt(obj, "totalRaids", 0), getInt(obj, "totalWars", 0), getInt(obj, "totalTickets", 0), getLong(obj, "endedAtMs", 0L), getBool(obj, "finalized"), ""); + } + + static CycleLeaderboardData.LifetimeSnapshot parseLifetimeSnapshot(JsonObject obj) { + String error = obj.has("error") && !obj.get("error").isJsonNull() ? get(obj, "error") : ""; + if (!error.isEmpty()) { + return CycleLeaderboardData.LifetimeSnapshot.error(error); + } + return new CycleLeaderboardData.LifetimeSnapshot(getBool(obj, "hasInterval"), getOptionalDouble(obj, "fromDays"), getOptionalDouble(obj, "toDays"), parseLeaderboardEntries(obj, "raids"), parseLeaderboardEntries(obj, "wars"), parsePodiumEntries(obj, "raidFinishes"), parsePodiumEntries(obj, "warFinishes"), ""); + } + + static CycleLeaderboardData.ConcludedCycleSummary parseConcludedCycleSummary(JsonObject obj) { + return new CycleLeaderboardData.ConcludedCycleSummary(get(obj, "cycleCode"), parseLeaderboardEntries(obj, "topRaids"), parseLeaderboardEntries(obj, "topWars"), parseRaffleWinners(obj), getInt(obj, "totalRaids", 0), getInt(obj, "totalWars", 0), getInt(obj, "totalTickets", 0)); + } } diff --git a/src/tel/eden/mod/net/CycleLeaderboardData.java b/src/tel/eden/mod/net/CycleLeaderboardData.java new file mode 100644 index 0000000..9d998f8 --- /dev/null +++ b/src/tel/eden/mod/net/CycleLeaderboardData.java @@ -0,0 +1,227 @@ +package tel.eden.mod.net; + +import java.time.DateTimeException; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** Models and ranking/interval validation helpers for Promotion Cycle and Lifetime leaderboards. */ +public final class CycleLeaderboardData { + private static final Pattern POSITIVE_NUMBER = Pattern.compile("^\\d+(?:\\.\\d+)?$"); + private static final Pattern CYCLE_CODE = Pattern.compile("^(\\d{2})(\\d{2})([AB])$"); + + private CycleLeaderboardData() { + } + + /** One ranked player row on either the cycle or lifetime leaderboard. */ + public record LeaderboardEntry(String uuid, String name, int count, int rank, Integer delta) { + } + + /** Lifetime cycle podium finishes (number of #1, #2, and #3 finishes across past cycles). */ + public record PodiumEntry(String uuid, String name, int first, int second, int third) { + } + + /** One promotion-cycle raffle winner (only top 3 are shown publicly). */ + public record RaffleWinner(String name, int tickets, int raids) { + } + + /** Validated custom day-interval bounds (`toDays == 0.0` means right now). */ + public record IntervalDays(double fromDays, double toDays) { + } + + /** Snapshot returned by {@code cycleLeaderboardReply}. */ + public record CycleSnapshot(String cycleCode, List cycles, List raids, List wars, List raffleWinners, int totalRaids, int totalWars, int totalTickets, long endedAtMs, boolean finalized, String error) { + public CycleSnapshot(String cycleCode, List cycles, List raids, List wars, List raffleWinners, int totalRaids, int totalWars, int totalTickets, String error) { + this(cycleCode, cycles, raids, wars, raffleWinners, totalRaids, totalWars, totalTickets, 0L, false, error); + } + + public static CycleSnapshot error(String message) { + return new CycleSnapshot("", List.of(), List.of(), List.of(), List.of(), 0, 0, 0, 0L, false, message); + } + } + + /** Snapshot returned by {@code lifetimeLeaderboardReply}. */ + public record LifetimeSnapshot(boolean hasInterval, Double fromDays, Double toDays, List raids, List wars, List raidFinishes, List warFinishes, String error) { + public static LifetimeSnapshot error(String message) { + return new LifetimeSnapshot(false, null, null, List.of(), List.of(), List.of(), List.of(), message); + } + } + + /** Broadcast payload sent to guild members when a promotion cycle concludes. */ + public record ConcludedCycleSummary(String cycleCode, List topRaids, List topWars, List raffleWinners, int totalRaids, int totalWars, int totalTickets) { + } + + /** Derive a printable concluded-cycle summary from any fetched cycle snapshot. */ + public static ConcludedCycleSummary summaryFromSnapshot(CycleSnapshot snap) { + List topRaids = snap.raids().stream().filter(e -> e.count() > 0 && e.rank() <= 3).toList(); + List topWars = snap.wars().stream().filter(e -> e.count() > 0 && e.rank() == 1).toList(); + List winners = snap.raffleWinners().subList(0, Math.min(3, snap.raffleWinners().size())); + return new ConcludedCycleSummary(snap.cycleCode(), topRaids, topWars, winners, snap.totalRaids(), snap.totalWars(), snap.totalTickets()); + } + + /** + * Sort entries descending by count (zeros at the bottom) and apply Standard Competition + * Ranking ({@code 1, 2, 2, 4}) so tied players share the same position. + */ + public static List rankEntries(List raw) { + if (raw == null || raw.isEmpty()) { + return List.of(); + } + List sorted = new ArrayList<>(raw); + sorted.sort(Comparator.comparingInt(LeaderboardEntry::count).reversed().thenComparing(e -> e.name().toLowerCase(java.util.Locale.ROOT))); + List out = new ArrayList<>(sorted.size()); + int prevCount = Integer.MIN_VALUE; + int prevRank = 0; + for (int i = 0; i < sorted.size(); i++) { + LeaderboardEntry entry = sorted.get(i); + int rank = (i > 0 && entry.count() == prevCount) ? prevRank : (i + 1); + prevCount = entry.count(); + prevRank = rank; + out.add(new LeaderboardEntry(entry.uuid(), entry.name(), entry.count(), rank, entry.delta())); + } + return List.copyOf(out); + } + + /** + * Return medal index ({@code 1}, {@code 2}, or {@code 3}) for {@code entry}, or {@code 0} for + * no medal (zero count, rank below 3, or interval-filtered leaderboards where medals are hidden). + */ + public static int medalForEntry(LeaderboardEntry entry, boolean showMedals) { + if (!showMedals || entry == null || entry.count() <= 0) { + return 0; + } + int rank = entry.rank(); + return rank >= 1 && rank <= 3 ? rank : 0; + } + + /** + * Parse user-entered interval fields ({@code From} and optional {@code To} days ago). + * Only positive integers/decimals are accepted; empty {@code To} means now ({@code 0.0}), + * and {@code From} must be strictly greater than {@code To}. Returns {@code null} on invalid input. + */ + public static IntervalDays parseIntervalDays(String fromRaw, String toRaw) { + if (fromRaw == null) { + return null; + } + String fromTrim = fromRaw.trim(); + if (fromTrim.isEmpty() || !POSITIVE_NUMBER.matcher(fromTrim).matches()) { + return null; + } + double fromVal; + try { + fromVal = Double.parseDouble(fromTrim); + } catch (NumberFormatException e) { + return null; + } + if (!Double.isFinite(fromVal) || fromVal <= 0.0) { + return null; + } + + double toVal = 0.0; + if (toRaw != null && !toRaw.trim().isEmpty()) { + String toTrim = toRaw.trim(); + if (!POSITIVE_NUMBER.matcher(toTrim).matches()) { + return null; + } + try { + toVal = Double.parseDouble(toTrim); + } catch (NumberFormatException e) { + return null; + } + if (!Double.isFinite(toVal) || toVal <= 0.0) { + return null; + } + } + if (fromVal <= toVal) { + return null; + } + return new IntervalDays(fromVal, toVal); + } + + /** Whether {@code snapshot} answers a request for {@code requestedCode} ({@code null}/empty means latest). */ + public static boolean matchesRequestedCycle(CycleSnapshot snapshot, String requestedCode) { + if (snapshot == null || !snapshot.error().isEmpty()) { + return false; + } + if (requestedCode == null || requestedCode.isBlank()) { + return snapshot.cycles().isEmpty() || snapshot.cycleCode().equals(snapshot.cycles().getLast()); + } + return requestedCode.trim().equals(snapshot.cycleCode()); + } + + /** Whether {@code snapshot} is an already-concluded historical cycle matching {@code cycleCode}. */ + public static boolean isHistoricalCycle(CycleSnapshot snapshot, String cycleCode) { + return cycleCode != null && !cycleCode.isBlank() && matchesRequestedCycle(snapshot, cycleCode) && !snapshot.cycles().isEmpty() && !cycleCode.trim().equals(snapshot.cycles().getLast()); + } + + /** Whether {@code snapshot} answers a lifetime/interval request for {@code (expectedFrom, expectedTo)}. */ + public static boolean matchesRequestedInterval(LifetimeSnapshot snapshot, Double expectedFrom, Double expectedTo) { + if (snapshot == null || !snapshot.error().isEmpty()) { + return false; + } + if (expectedFrom == null) { + return !snapshot.hasInterval(); + } + if (!snapshot.hasInterval() || snapshot.fromDays() == null) { + return false; + } + double expTo = expectedTo != null ? expectedTo : 0.0; + double actTo = snapshot.toDays() != null ? snapshot.toDays() : 0.0; + return Math.abs(expectedFrom - snapshot.fromDays()) < 1.0e-6 && Math.abs(expTo - actTo) < 1.0e-6; + } + + /** Cycles 2503A and earlier counted both Party Finder and guild raids in historical tracking. */ + public static boolean countsPartyFinderRaids(String cycleCode) { + if (cycleCode == null) { + return false; + } + String trimmed = cycleCode.trim(); + return CYCLE_CODE.matcher(trimmed).matches() && trimmed.compareTo("2503A") <= 0; + } + + /** Resolve the cycle's end timestamp in epoch ms (falling back to UTC half-month boundaries from {@code cycleCode}). */ + public static long cycleEndEpochMs(CycleSnapshot snapshot) { + if (snapshot == null) { + return 0L; + } + if (snapshot.endedAtMs() > 0L) { + return snapshot.endedAtMs(); + } + String code = snapshot.cycleCode(); + if (code == null) { + return 0L; + } + Matcher m = CYCLE_CODE.matcher(code.trim()); + if (!m.matches()) { + return 0L; + } + int year = 2000 + Integer.parseInt(m.group(1)); + int month = Integer.parseInt(m.group(2)); + try { + LocalDate endDate = "A".equals(m.group(3)) ? LocalDate.of(year, month, 15) : LocalDate.of(year, month, 1).plusMonths(1); + return endDate.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(); + } catch (DateTimeException e) { + return 0L; + } + } + + /** Format the cycle-end countdown (or {@code "Ended"} once concluded), or empty if unknown. */ + public static String cycleEndText(CycleSnapshot snapshot, long nowMs) { + if (snapshot == null) { + return ""; + } + long endMs = cycleEndEpochMs(snapshot); + if (endMs <= 0L) { + return snapshot.finalized() ? "Ended" : ""; + } + if (snapshot.finalized() || isHistoricalCycle(snapshot, snapshot.cycleCode())) { + return "Ended"; + } + long remainingMs = endMs - nowMs; + return remainingMs > 0L ? "Ends in " + LongEventState.formatCountdown(remainingMs, true) : "Ended"; + } +} diff --git a/src/tel/eden/mod/net/OutboundPolicy.java b/src/tel/eden/mod/net/OutboundPolicy.java index 8935800..7f154f0 100644 --- a/src/tel/eden/mod/net/OutboundPolicy.java +++ b/src/tel/eden/mod/net/OutboundPolicy.java @@ -27,7 +27,7 @@ public static Standing of(boolean linked, boolean member, boolean traveler) { private OutboundPolicy() { } - private static final Set GUILD_ONLY_INBOUND = Set.of("warBoard", "discordMessage", "loginNotice", "logoutNotice", "onlineList"); + private static final Set GUILD_ONLY_INBOUND = Set.of("warBoard", "discordMessage", "loginNotice", "logoutNotice", "onlineList", "cycleLeaderboardReply", "lifetimeLeaderboardReply", "cycleConcluded"); /** Defence in depth: the server never sends these to a traveler, so drop them if one arrives. */ public static boolean inboundAllowed(Standing standing, String type) { diff --git a/src/tel/eden/mod/util/PlayerSkinResolver.java b/src/tel/eden/mod/util/PlayerSkinResolver.java index ea907a8..7c6062c 100644 --- a/src/tel/eden/mod/util/PlayerSkinResolver.java +++ b/src/tel/eden/mod/util/PlayerSkinResolver.java @@ -1,24 +1,34 @@ package tel.eden.mod.util; +import com.mojang.authlib.GameProfile; import java.nio.charset.StandardCharsets; import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.regex.Pattern; import net.minecraft.client.Minecraft; import net.minecraft.client.multiplayer.PlayerInfo; import net.minecraft.client.resources.DefaultPlayerSkin; import net.minecraft.world.entity.player.PlayerSkin; +import tel.eden.mod.EdenLogger; /** - * Resolves player skins for HUDs and menus, serving from the local client player list - * or an off-thread Mojang profile cache, falling back to a Steve/Alex skin. + * Shared player skin resolver for HUDs and menus, checking the live player list (when textures are + * populated) then the shared Mojang-resolved cache, with an off-thread rate-limited session lookup. */ public final class PlayerSkinResolver { + private static final EdenLogger LOGGER = EdenLogger.get(); + private static final Pattern DASHLESS_UUID = Pattern.compile("(\\p{XDigit}{8})(\\p{XDigit}{4})(\\p{XDigit}{4})(\\p{XDigit}{4})(\\p{XDigit}{12})"); private static final Map RESOLVED_SKINS = new ConcurrentHashMap<>(); private static final Map SKIN_NEXT_ATTEMPT = new ConcurrentHashMap<>(); + private static final Map IN_FLIGHT = new ConcurrentHashMap<>(); + private static final AtomicInteger SESSION_GEN = new AtomicInteger(); private static final long SKIN_RETRY_MS = 30_000L; + private static final long SKIN_FAIL_RETRY_MS = 10_000L; + private static final long WORKER_PACE_MS = 200L; private static final ExecutorService SKIN_WORKER = Executors.newSingleThreadExecutor(runnable -> { Thread thread = new Thread(runnable, "eden-skin-resolver"); thread.setDaemon(true); @@ -28,33 +38,71 @@ public final class PlayerSkinResolver { private PlayerSkinResolver() { } + /** Parse either a hyphenated or 32-char dashless UUID string, returning {@code null} if invalid. */ + public static UUID parseUuid(String raw) { + if (raw == null || raw.isBlank()) { + return null; + } + String trimmed = raw.trim(); + if (trimmed.length() == 32 && trimmed.indexOf('-') < 0) { + trimmed = DASHLESS_UUID.matcher(trimmed).replaceFirst("$1-$2-$3-$4-$5"); + } + try { + return UUID.fromString(trimmed); + } catch (IllegalArgumentException e) { + return null; + } + } + + /** Resolve a skin from a raw UUID string (optional) and fallback IGN. */ + public static PlayerSkin skinForId(Minecraft mc, String uuidStr, String name) { + return skinFor(mc, parseUuid(uuidStr), name); + } + + /** Resolve a skin by parsed UUID and fallback IGN. */ public static PlayerSkin skinFor(Minecraft mc, UUID uuid, String name) { if (uuid == null) { - if (name != null && !name.isBlank()) { - uuid = UUID.nameUUIDFromBytes(name.getBytes(StandardCharsets.UTF_8)); - } else { + if (name == null || name.isBlank()) { return DefaultPlayerSkin.getDefaultSkin(); } - } - if (mc != null && mc.getConnection() != null) { - PlayerInfo info = mc.getConnection().getPlayerInfo(uuid); - if (info == null && name != null && !name.isBlank()) { - info = mc.getConnection().getPlayerInfo(name); - } - if (info != null) { - return info.getSkin(); + PlayerSkin online = onlineSkin(mc, null, name); + if (online != null) { + return online; } + return DefaultPlayerSkin.get(UUID.nameUUIDFromBytes(name.getBytes(StandardCharsets.UTF_8))); + } + PlayerSkin online = onlineSkin(mc, uuid, name); + if (online != null) { + return online; } PlayerSkin resolved = RESOLVED_SKINS.get(uuid); if (resolved != null) { return resolved; } - fetchSkin(mc, uuid); + if (uuid.version() != 3) { + fetchSkin(mc, uuid, name); + } return DefaultPlayerSkin.get(uuid); } - private static void fetchSkin(Minecraft mc, UUID uuid) { - if (mc == null) { + private static PlayerSkin onlineSkin(Minecraft mc, UUID uuid, String name) { + if (mc == null || mc.getConnection() == null) { + return null; + } + PlayerInfo info = uuid != null ? mc.getConnection().getPlayerInfo(uuid) : null; + if (info == null && name != null && !name.isBlank()) { + info = mc.getConnection().getPlayerInfo(name); + } + // Wynncraft cross-world tab/guild entries often omit texture properties; fall back to + // Mojang session lookup unless the live entry actually carries a texture property. + if (info != null && !info.getProfile().properties().get("textures").isEmpty()) { + return info.getSkin(); + } + return null; + } + + private static void fetchSkin(Minecraft mc, UUID uuid, String name) { + if (mc == null || IN_FLIGHT.containsKey(uuid)) { return; } long now = System.currentTimeMillis(); @@ -62,21 +110,65 @@ private static void fetchSkin(Minecraft mc, UUID uuid) { if (next != null && now < next) { return; } + int gen = SESSION_GEN.get(); + if (IN_FLIGHT.putIfAbsent(uuid, gen) != null) { + return; + } + // Re-check after claiming in case reset() raced cleanly across threads. + if (gen != SESSION_GEN.get()) { + IN_FLIGHT.remove(uuid, gen); + return; + } SKIN_NEXT_ATTEMPT.put(uuid, now + SKIN_RETRY_MS); + LOGGER.debug("Resolving skin for {} ({})", name, uuid); SKIN_WORKER.submit(() -> { + if (gen != SESSION_GEN.get()) { + IN_FLIGHT.remove(uuid, gen); + return; + } try { - var result = mc.services().sessionService().fetchProfile(uuid, false); - if (result != null) { - com.mojang.authlib.GameProfile profile = result.profile(); - mc.execute(() -> mc.getSkinManager().get(profile).thenAccept(skin -> skin.ifPresent(value -> RESOLVED_SKINS.put(uuid, value)))); + // requireSecure=true avoids Yggdrasil's 6h negative cache when rate-limited (HTTP 429). + var result = mc.services().sessionService().fetchProfile(uuid, true); + if (gen != SESSION_GEN.get()) { + return; + } + if (result != null && result.profile() != null) { + GameProfile profile = result.profile(); + mc.execute(() -> { + if (gen != SESSION_GEN.get()) { + return; + } + mc.getSkinManager().get(profile).thenAccept(skin -> { + if (gen == SESSION_GEN.get()) { + skin.ifPresent(value -> RESOLVED_SKINS.put(uuid, value)); + } + }); + }); + } else { + SKIN_NEXT_ATTEMPT.put(uuid, System.currentTimeMillis() + SKIN_FAIL_RETRY_MS); + } + } catch (RuntimeException e) { + LOGGER.debug("Skin fetch failed for {}", uuid, e); + if (gen == SESSION_GEN.get()) { + SKIN_NEXT_ATTEMPT.put(uuid, System.currentTimeMillis() + SKIN_FAIL_RETRY_MS); + } + } finally { + IN_FLIGHT.remove(uuid, gen); + if (gen == SESSION_GEN.get()) { + try { + Thread.sleep(WORKER_PACE_MS); + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + } } - } catch (Exception ignored) { } }); } public static void reset() { + SESSION_GEN.incrementAndGet(); RESOLVED_SKINS.clear(); SKIN_NEXT_ATTEMPT.clear(); + IN_FLIGHT.clear(); } } diff --git a/src/tel/eden/mod/war/AttackTimerMenu.java b/src/tel/eden/mod/war/AttackTimerMenu.java index cbf4c4a..d6e73bb 100644 --- a/src/tel/eden/mod/war/AttackTimerMenu.java +++ b/src/tel/eden/mod/war/AttackTimerMenu.java @@ -1,15 +1,10 @@ package tel.eden.mod.war; -import com.mojang.authlib.GameProfile; -import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; import java.util.regex.Matcher; import java.util.regex.Pattern; import net.minecraft.client.Minecraft; @@ -17,7 +12,6 @@ import net.minecraft.client.gui.GuiGraphics; import net.minecraft.client.gui.components.PlayerFaceRenderer; import net.minecraft.client.multiplayer.PlayerInfo; -import net.minecraft.client.resources.DefaultPlayerSkin; import net.minecraft.core.BlockPos; import net.minecraft.world.entity.player.PlayerSkin; import net.minecraft.world.scores.DisplaySlot; @@ -26,7 +20,6 @@ import net.minecraft.world.scores.PlayerTeam; import net.minecraft.world.scores.Scoreboard; import org.lwjgl.glfw.GLFW; -import tel.eden.mod.EdenLogger; import tel.eden.mod.EdenModClient; import tel.eden.mod.chat.ChatText; import tel.eden.mod.config.BridgeConfig; @@ -38,6 +31,7 @@ import tel.eden.mod.net.WarBoardEntry; import tel.eden.mod.net.WarGoer; import tel.eden.mod.net.WarQueuer; +import tel.eden.mod.util.PlayerSkinResolver; /** * HUD list of upcoming territory attacks read from the scoreboard sidebar, each row @@ -863,79 +857,12 @@ private static String nameFor(Minecraft mc, String uuidStr, String fallbackName) return fallbackName; } - private static final EdenLogger LOGGER = EdenLogger.get(); - /** Skins resolved by uuid from Mojang, for goers not in our player list (cross-world). */ - private static final Map resolvedSkins = new ConcurrentHashMap<>(); - /** - * Earliest time (ms) each uuid may be (re)fetched. Set on every attempt so a failed or - * empty resolve backs off instead of re-submitting every frame; a success caches into - * {@link #resolvedSkins} and is served before this map is ever consulted again. - */ - private static final Map skinNextAttempt = new ConcurrentHashMap<>(); - private static final long SKIN_RETRY_MS = 30_000L; - private static final ExecutorService skinWorker = Executors.newSingleThreadExecutor(runnable -> { - Thread thread = new Thread(runnable, "eden-war-skins"); - thread.setDaemon(true); - return thread; - }); - - /** - * The skin to draw for a player head. A guildmate on our own world is in the player list with - * their skin already loaded (free). One on a different Wynncraft world instance - * (routine during a war rush) isn't in our list, so their profile carries no textures and - * the game would only give a default skin — we resolve those by uuid from Mojang in the - * background (cached), showing the default until it lands. - */ private static PlayerSkin skinFor(Minecraft mc, WarGoer goer) { return skinFor(mc, goer.uuid(), goer.name()); } private static PlayerSkin skinFor(Minecraft mc, String uuidStr, String fallbackName) { - UUID uuid; - try { - uuid = UUID.fromString(uuidStr); - } catch (IllegalArgumentException e) { - return DefaultPlayerSkin.get(UUID.nameUUIDFromBytes(fallbackName.getBytes(StandardCharsets.UTF_8))); - } - if (mc.getConnection() != null) { - PlayerInfo info = mc.getConnection().getPlayerInfo(uuid); - if (info != null) { - return info.getSkin(); - } - } - PlayerSkin resolved = resolvedSkins.get(uuid); - if (resolved != null) { - return resolved; - } - fetchSkin(mc, uuid, fallbackName); - return DefaultPlayerSkin.get(uuid); - } - - /** - * Resolve a goer's skin by uuid off-thread (Mojang session lookup → texture load), - * caching the result. Rate-limited per uuid ({@link #SKIN_RETRY_MS}) so a failed or - * empty resolve backs off instead of re-submitting every frame the head is drawn; a - * success caches the skin, which is then served before this method is called again. - */ - private static void fetchSkin(Minecraft mc, UUID uuid, String name) { - long now = System.currentTimeMillis(); - Long next = skinNextAttempt.get(uuid); - if (next != null && now < next) { - return; - } - skinNextAttempt.put(uuid, now + SKIN_RETRY_MS); - LOGGER.debug("Resolving war-head skin for {} ({}) — not in the player list", name, uuid); - skinWorker.submit(() -> { - try { - var result = mc.services().sessionService().fetchProfile(uuid, false); - if (result != null) { - GameProfile profile = result.profile(); - mc.execute(() -> mc.getSkinManager().get(profile).thenAccept(skin -> skin.ifPresent(value -> resolvedSkins.put(uuid, value)))); - } - } catch (RuntimeException e) { - LOGGER.debug("War-head skin fetch failed for {}", uuid, e); - } - }); + return PlayerSkinResolver.skinForId(mc, uuidStr, fallbackName); } /** diff --git a/test/tel/eden/mod/net/CycleLeaderboardTest.java b/test/tel/eden/mod/net/CycleLeaderboardTest.java new file mode 100644 index 0000000..c131419 --- /dev/null +++ b/test/tel/eden/mod/net/CycleLeaderboardTest.java @@ -0,0 +1,151 @@ +package tel.eden.mod.net; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.google.gson.JsonParser; +import java.util.List; +import net.minecraft.network.chat.Component; +import org.junit.jupiter.api.Test; +import tel.eden.mod.chat.DiscordChatFormatter; + +class CycleLeaderboardTest { + @Test + void standardCompetitionRankingAndZeros() { + List ranked = CycleLeaderboardData.rankEntries(List.of(new CycleLeaderboardData.LeaderboardEntry("u2", "Bob", 10, 0, 1), new CycleLeaderboardData.LeaderboardEntry("u3", "Carol", 0, 0, null), new CycleLeaderboardData.LeaderboardEntry("u1", "Alice", 10, 0, 0), new CycleLeaderboardData.LeaderboardEntry("u4", "Dave", 5, 0, -2))); + assertEquals(4, ranked.size()); + assertEquals("Alice", ranked.get(0).name()); + assertEquals(1, ranked.get(0).rank()); + assertEquals("Bob", ranked.get(1).name()); + assertEquals(1, ranked.get(1).rank()); + assertEquals("Dave", ranked.get(2).name()); + assertEquals(3, ranked.get(2).rank()); + assertEquals("Carol", ranked.get(3).name()); + assertEquals(4, ranked.get(3).rank()); + assertEquals(0, ranked.get(3).count()); + + assertEquals(1, CycleLeaderboardData.medalForEntry(ranked.get(0), true)); + assertEquals(1, CycleLeaderboardData.medalForEntry(ranked.get(1), true)); + assertEquals(3, CycleLeaderboardData.medalForEntry(ranked.get(2), true)); + assertEquals(0, CycleLeaderboardData.medalForEntry(ranked.get(3), true)); + assertEquals(0, CycleLeaderboardData.medalForEntry(ranked.get(0), false)); + } + + @Test + void intervalValidation() { + CycleLeaderboardData.IntervalDays openEnded = CycleLeaderboardData.parseIntervalDays("14.5", ""); + assertNotNull(openEnded); + assertEquals(14.5, openEnded.fromDays(), 1e-9); + assertEquals(0.0, openEnded.toDays(), 1e-9); + + CycleLeaderboardData.IntervalDays bounded = CycleLeaderboardData.parseIntervalDays("30", "7.25"); + assertNotNull(bounded); + assertEquals(30.0, bounded.fromDays(), 1e-9); + assertEquals(7.25, bounded.toDays(), 1e-9); + + assertNull(CycleLeaderboardData.parseIntervalDays("", "")); + assertNull(CycleLeaderboardData.parseIntervalDays("-5", "")); + assertNull(CycleLeaderboardData.parseIntervalDays("0", "")); + assertNull(CycleLeaderboardData.parseIntervalDays("5", "-1")); + assertNull(CycleLeaderboardData.parseIntervalDays("5", "5")); + assertNull(CycleLeaderboardData.parseIntervalDays("3", "7")); + assertNull(CycleLeaderboardData.parseIntervalDays("abc", "")); + } + + @Test + void cycleConcludedAndPrintFormattingCapRaffleToThree() { + Component announcement = DiscordChatFormatter.cycleConcluded("2604A"); + String text = announcement.getString(); + assertTrue(text.contains("The promotion cycle has concluded!")); + assertTrue(text.contains("[Print]")); + assertTrue(text.contains("[View]")); + + CycleLeaderboardData.ConcludedCycleSummary summary = new CycleLeaderboardData.ConcludedCycleSummary("2604A", List.of(new CycleLeaderboardData.LeaderboardEntry("u1", "Alice", 40, 1, null), new CycleLeaderboardData.LeaderboardEntry("u2", "Bob", 35, 2, null), new CycleLeaderboardData.LeaderboardEntry("u3", "Carol", 30, 3, null), new CycleLeaderboardData.LeaderboardEntry("u4", "Dave", 20, 4, null)), List.of(new CycleLeaderboardData.LeaderboardEntry("u2", "Bob", 55, 1, null)), List.of(new CycleLeaderboardData.RaffleWinner("Alice", 8, 40), new CycleLeaderboardData.RaffleWinner("Bob", 7, 35), new CycleLeaderboardData.RaffleWinner("Carol", 6, 30), new CycleLeaderboardData.RaffleWinner("Dave", 4, 20)), 125, 55, 25); + String printed = DiscordChatFormatter.formatCyclePrint(summary).getString(); + assertTrue(printed.contains("Top 3 Raids:")); + assertTrue(printed.contains("Alice")); + assertTrue(printed.contains("Carol")); + assertTrue(printed.contains("Top 1 Wars:")); + assertTrue(printed.contains("Top 3 Raffle:")); + assertFalse(printed.contains("Dave")); + assertTrue(printed.contains("125 raids | 55 wars | 25 tickets")); + } + + @Test + void outboundBlocksObserversAndTravelersFromCycleRequests() { + for (String type : List.of("cycleLeaderboardRequest", "lifetimeLeaderboardRequest")) { + assertFalse(OutboundPolicy.allowed(OutboundPolicy.Standing.UNKNOWN, type)); + assertFalse(OutboundPolicy.allowed(OutboundPolicy.Standing.NOT_LINKED, type)); + assertFalse(OutboundPolicy.allowed(OutboundPolicy.Standing.NOT_MEMBER, type)); + assertFalse(OutboundPolicy.allowed(OutboundPolicy.Standing.TRAVELER, type)); + assertTrue(OutboundPolicy.allowed(OutboundPolicy.Standing.FULL, type)); + } + for (String reply : List.of("cycleLeaderboardReply", "lifetimeLeaderboardReply", "cycleConcluded")) { + assertFalse(OutboundPolicy.inboundAllowed(OutboundPolicy.Standing.TRAVELER, reply)); + assertTrue(OutboundPolicy.inboundAllowed(OutboundPolicy.Standing.FULL, reply)); + } + } + + @Test + void jsonParsersPreserveErrorStrings() { + var cycleErr = BridgeWebSocketClient.parseCycleSnapshot(JsonParser.parseString("{\"type\":\"cycleLeaderboardReply\",\"error\":\"Failed to fetch cycle leaderboard\"}").getAsJsonObject()); + assertEquals("Failed to fetch cycle leaderboard", cycleErr.error()); + + var lifeErr = BridgeWebSocketClient.parseLifetimeSnapshot(JsonParser.parseString("{\"type\":\"lifetimeLeaderboardReply\",\"error\":\"Failed to fetch leaderboard stats\"}").getAsJsonObject()); + assertEquals("Failed to fetch leaderboard stats", lifeErr.error()); + } + + @Test + void requestMatchingAndHistoricalCycleDetection() { + CycleLeaderboardData.CycleSnapshot archive = new CycleLeaderboardData.CycleSnapshot("2603B", List.of("2603A", "2603B", "2604A"), List.of(), List.of(), List.of(), 10, 5, 1, ""); + CycleLeaderboardData.CycleSnapshot current = new CycleLeaderboardData.CycleSnapshot("2604A", List.of("2603A", "2603B", "2604A"), List.of(), List.of(), List.of(), 20, 8, 2, ""); + + assertTrue(CycleLeaderboardData.matchesRequestedCycle(archive, "2603B")); + assertFalse(CycleLeaderboardData.matchesRequestedCycle(archive, "")); + assertFalse(CycleLeaderboardData.matchesRequestedCycle(archive, "2604A")); + assertTrue(CycleLeaderboardData.matchesRequestedCycle(current, "")); + assertTrue(CycleLeaderboardData.matchesRequestedCycle(current, "2604A")); + + assertTrue(CycleLeaderboardData.isHistoricalCycle(archive, "2603B")); + assertFalse(CycleLeaderboardData.isHistoricalCycle(archive, "")); + assertFalse(CycleLeaderboardData.isHistoricalCycle(current, "2604A")); + assertFalse(CycleLeaderboardData.isHistoricalCycle(CycleLeaderboardData.CycleSnapshot.error("err"), "2603B")); + + CycleLeaderboardData.LifetimeSnapshot interval = new CycleLeaderboardData.LifetimeSnapshot(true, 14.0, 0.0, List.of(), List.of(), List.of(), List.of(), ""); + CycleLeaderboardData.LifetimeSnapshot allTime = new CycleLeaderboardData.LifetimeSnapshot(false, null, null, List.of(), List.of(), List.of(), List.of(), ""); + assertTrue(CycleLeaderboardData.matchesRequestedInterval(interval, 14.0, 0.0)); + assertTrue(CycleLeaderboardData.matchesRequestedInterval(interval, 14.0, null)); + assertFalse(CycleLeaderboardData.matchesRequestedInterval(interval, null, null)); + assertTrue(CycleLeaderboardData.matchesRequestedInterval(allTime, null, null)); + assertFalse(CycleLeaderboardData.matchesRequestedInterval(allTime, 14.0, 0.0)); + } + + @Test + void countsPartyFinderRaidsFor2503AAndBelow() { + assertTrue(CycleLeaderboardData.countsPartyFinderRaids("2503A")); + assertTrue(CycleLeaderboardData.countsPartyFinderRaids("2501B")); + assertTrue(CycleLeaderboardData.countsPartyFinderRaids("2412B")); + assertFalse(CycleLeaderboardData.countsPartyFinderRaids("2503B")); + assertFalse(CycleLeaderboardData.countsPartyFinderRaids("2604A")); + assertFalse(CycleLeaderboardData.countsPartyFinderRaids("")); + assertFalse(CycleLeaderboardData.countsPartyFinderRaids(null)); + } + + @Test + void cycleEndTimerUsesPayloadAndUtcFallback() { + long explicitEnd = java.time.Instant.parse("2026-12-01T00:00:00Z").toEpochMilli(); + var parsed = BridgeWebSocketClient.parseCycleSnapshot(JsonParser.parseString("{\"type\":\"cycleLeaderboardReply\",\"cycleCode\":\"2611B\",\"cycles\":[\"2611A\",\"2611B\"],\"endedAtMs\":" + explicitEnd + ",\"finalized\":false}").getAsJsonObject()); + assertEquals(explicitEnd, CycleLeaderboardData.cycleEndEpochMs(parsed)); + assertEquals("Ends in 1d 02:03:04", CycleLeaderboardData.cycleEndText(parsed, explicitEnd - ((86_400L + 7_200L + 180L + 4L) * 1000L))); + assertEquals("Ended", CycleLeaderboardData.cycleEndText(parsed, explicitEnd)); + + CycleLeaderboardData.CycleSnapshot decFallback = new CycleLeaderboardData.CycleSnapshot("2612B", List.of("2612A", "2612B"), List.of(), List.of(), List.of(), 0, 0, 0, ""); + assertEquals(java.time.Instant.parse("2027-01-01T00:00:00Z").toEpochMilli(), CycleLeaderboardData.cycleEndEpochMs(decFallback)); + + CycleLeaderboardData.CycleSnapshot finalized = new CycleLeaderboardData.CycleSnapshot("2611B", List.of("2611B"), List.of(), List.of(), List.of(), 0, 0, 0, explicitEnd, true, ""); + assertEquals("Ended", CycleLeaderboardData.cycleEndText(finalized, explicitEnd - 60_000L)); + } +} diff --git a/test/tel/eden/mod/net/OutboundPolicyTest.java b/test/tel/eden/mod/net/OutboundPolicyTest.java index 03bd8f2..3545d5f 100644 --- a/test/tel/eden/mod/net/OutboundPolicyTest.java +++ b/test/tel/eden/mod/net/OutboundPolicyTest.java @@ -21,7 +21,7 @@ class OutboundPolicyTest { // Every type BWSC sends that a traveler must NOT be able to send. A new send* type that is // in neither set fails classifiesEveryTypeBwscCanSend until someone decides. - private static final Set GUILD_ONLY = Set.of("allyActivityRequest", "annihilation", "aspectGiveawayRequest", "aspectsPendingRequest", "bankEvent", "emeraldsPendingRequest", "giftLockAcquire", "giftLockRelease", "guildAlliances", "guildAnnounce", "guildEvent", "guildLogSnapshot", "guildManageStatus", "guildReward", "guildStorage", "guildTomeFound", "itemCard", "login", "longEventMysteryGuess", "longEventReroll", "longEventRewardsRequest", "longEventStateRequest", "onlineRequest", "radianceCast", "radianceGroup", "raidCompletion", "rankChange", "rewardDeductRequest", "rewardOptOutRequest", "rewardStatusRequest", "territoryDefended", "warAttended", "warCountsRequest", "warDefense", "warGoing", "warGoingInside", "warQueued", "warTimerEnded", "wynnMessage"); + private static final Set GUILD_ONLY = Set.of("allyActivityRequest", "annihilation", "aspectGiveawayRequest", "aspectsPendingRequest", "bankEvent", "cycleLeaderboardRequest", "emeraldsPendingRequest", "giftLockAcquire", "giftLockRelease", "guildAlliances", "guildAnnounce", "guildEvent", "guildLogSnapshot", "guildManageStatus", "guildReward", "guildStorage", "guildTomeFound", "itemCard", "lifetimeLeaderboardRequest", "login", "longEventMysteryGuess", "longEventReroll", "longEventRewardsRequest", "longEventStateRequest", "onlineRequest", "radianceCast", "radianceGroup", "raidCompletion", "rankChange", "rewardDeductRequest", "rewardOptOutRequest", "rewardStatusRequest", "territoryDefended", "warAttended", "warCountsRequest", "warDefense", "warGoing", "warGoingInside", "warQueued", "warTimerEnded", "wynnMessage"); @Test void travelerGetsExactlyTheAllowlist() { diff --git a/test/tel/eden/mod/util/PlayerSkinResolverTest.java b/test/tel/eden/mod/util/PlayerSkinResolverTest.java index e46cba1..dc9c629 100644 --- a/test/tel/eden/mod/util/PlayerSkinResolverTest.java +++ b/test/tel/eden/mod/util/PlayerSkinResolverTest.java @@ -1,8 +1,11 @@ package tel.eden.mod.util; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; +import java.util.UUID; import net.minecraft.client.resources.DefaultPlayerSkin; import net.minecraft.world.entity.player.PlayerSkin; import org.junit.jupiter.api.Test; @@ -22,4 +25,23 @@ void returnsDefaultSkinImmediatelyWhenUuidAndNameAreAbsent() { PlayerSkin blankName = PlayerSkinResolver.skinFor(null, null, " "); assertSame(expected, blankName, "Must return DefaultPlayerSkin directly when name is blank"); } + + @Test + void parsesDashedAndDashlessUuids() { + UUID expected = UUID.fromString("387c49fd-f06c-47b7-97a6-b97a5ecc0bd3"); + assertEquals(expected, PlayerSkinResolver.parseUuid("387c49fd-f06c-47b7-97a6-b97a5ecc0bd3")); + assertEquals(expected, PlayerSkinResolver.parseUuid(" 387c49fdf06c47b797a6b97a5ecc0bd3 ")); + assertNull(PlayerSkinResolver.parseUuid("not-a-uuid")); + assertNull(PlayerSkinResolver.parseUuid("")); + assertNull(PlayerSkinResolver.parseUuid(null)); + } + + @Test + void resetSafelyBumpsGenerationAndKeepsFallbackSkinsAvailable() { + PlayerSkinResolver.reset(); + PlayerSkin skin = PlayerSkinResolver.skinFor(null, UUID.fromString("387c49fd-f06c-47b7-97a6-b97a5ecc0bd3"), "Hino1712"); + assertNotNull(skin); + PlayerSkinResolver.reset(); + assertSame(DefaultPlayerSkin.getDefaultSkin(), PlayerSkinResolver.skinFor(null, null, null)); + } }