Serverübergreifender Chat als Velocity-Plugin

src/main/java/eu/mhsl/craftattack/chatbridge/Chat.java

@@ -0,0 +1,135 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ProxyServer;
+import com.velocitypowered.api.proxy.ServerConnection;
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.sound.Sound;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextColor;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Öffentlicher Chat: Velocity schickt jede Zeile als Systemnachricht an alle Spieler im Netzwerk.
+ * Die Backends verwerfen den Chat selbst (spawn, Limbo), sonst stünde er dort doppelt.
+ */
+final class Chat {
+    private static final TextColor GRAY = TextColor.color(0x808080);
+    private static final TextColor SILVER = TextColor.color(0xC0C0C0);
+    /** Wort mit optionalem @ davor und Satzzeichen dahinter; Bedrock-Namen beginnen mit einem Punkt. */
+    private static final Pattern WORD = Pattern.compile("(@?)(\\.?[A-Za-z0-9_]{1,16})([.,!?:;]*)");
+    private static final Sound MENTION = Sound.sound(Key.key("entity.experience_orb.pickup"), Sound.Source.PLAYER, 1f, 1f);
+
+    private final ProxyServer proxy;
+    private final Logger logger;
+    private final Config config;
+    private final Names names;
+    private final Mutes mutes;
+
+    Chat(ProxyServer proxy, Logger logger, Config config, Names names, Mutes mutes) {
+        this.proxy = proxy;
+        this.logger = logger;
+        this.config = config;
+        this.names = names;
+        this.mutes = mutes;
+    }
+
+    void handle(Player sender, String message) {
+        String server = serverOf(sender);
+        if (this.denyMuted(sender)) {
+            this.logger.info("[chat] [{}] {} (gestummt): {}", server, sender.getUsername(), message);
+            return;
+        }
+
+        Set<Player> mentioned = new LinkedHashSet<>();
+        Component line = Component.text()
+                .append(this.tag(server))
+                .append(this.names.clickable(sender))
+                .append(Component.text(" > ", GRAY))
+                .append(this.body(message, mentioned).colorIfAbsent(SILVER))
+                .build();
+
+        for (Player player : this.proxy.getAllPlayers()) {
+            if (server != null && this.config.unsilencedServers().contains(server) && server.equals(serverOf(player))) continue;
+            player.sendMessage(line);
+        }
+        mentioned.stream()
+                .filter(player -> !player.equals(sender))
+                .forEach(player -> player.playSound(MENTION));
+
+        this.logger.info("[chat] [{}] {}: {}", server, sender.getUsername(), message);
+    }
+
+    void announceJoin(Player player) {
+        this.broadcast(Component.text(">>> ", NamedTextColor.GREEN).append(this.names.clickable(player)));
+    }
+
+    void announceLeave(Player player) {
+        this.broadcast(Component.text("<<< ", NamedTextColor.RED).append(this.names.clickable(player)));
+    }
+
+    void broadcast(Component line) {
+        this.proxy.getAllPlayers().forEach(player -> player.sendMessage(line));
+    }
+
+    /** Meldet einem gestummten Spieler die Restzeit; true, wenn er gestummt ist. */
+    boolean denyMuted(Player player) {
+        Optional<Instant> until = this.mutes.mutedUntil(player.getUniqueId());
+        if (until.isEmpty()) return false;
+        player.sendMessage(Component.text(
+                "Du bist für " + Mutes.format(Duration.between(Instant.now(), until.get())) + " gestummt!",
+                NamedTextColor.RED));
+        return true;
+    }
+
+    private Component tag(@Nullable String server) {
+        String tag = server == null ? null : this.config.serverTags().get(server);
+        if (tag == null) return Component.empty();
+        return Component.text("[" + tag + "] ", NamedTextColor.DARK_GRAY);
+    }
+
+    /** Text der Nachricht; Namen von Spielern im Netzwerk werden golden als @Name hervorgehoben. */
+    private Component body(String message, Set<Player> mentioned) {
+        Map<String, Player> online = new HashMap<>();
+        this.proxy.getAllPlayers().forEach(player -> online.put(player.getUsername().toLowerCase(Locale.ROOT), player));
+
+        TextComponent.Builder body = Component.text();
+        Matcher matcher = WORD.matcher(message);
+        int last = 0;
+        while (matcher.find()) {
+            Player target = online.get(matcher.group(2).toLowerCase(Locale.ROOT));
+            if (target == null || !isWordBoundary(message, matcher)) continue;
+            body.append(Component.text(message.substring(last, matcher.start())));
+            body.append(Component.text("@" + target.getUsername(), NamedTextColor.GOLD));
+            body.append(Component.text(matcher.group(3)));
+            mentioned.add(target);
+            last = matcher.end();
+        }
+        body.append(Component.text(message.substring(last)));
+        return body.build();
+    }
+
+    private static boolean isWordBoundary(String message, Matcher matcher) {
+        boolean startOk = matcher.start() == 0 || Character.isWhitespace(message.charAt(matcher.start() - 1));
+        boolean endOk = matcher.end() == message.length() || Character.isWhitespace(message.charAt(matcher.end()));
+        return startOk && endOk;
+    }
+
+    static @Nullable String serverOf(Player player) {
+        return player.getCurrentServer().map(ServerConnection::getServerInfo).map(info -> info.getName()).orElse(null);
+    }
+}

src/main/java/eu/mhsl/craftattack/chatbridge/ChatBridge.java

@@ -0,0 +1,61 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import com.google.inject.Inject;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
+import com.velocitypowered.api.plugin.Dependency;
+import com.velocitypowered.api.plugin.Plugin;
+import com.velocitypowered.api.plugin.annotation.DataDirectory;
+import com.velocitypowered.api.proxy.ProxyServer;
+import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
+import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
+import net.luckperms.api.LuckPermsProvider;
+import org.slf4j.Logger;
+
+import java.nio.file.Path;
+
+@Plugin(
+        id = "chat-bridge",
+        name = "chat-bridge",
+        version = "1.0.0",
+        description = "Serverübergreifender Chat: öffentlicher Chat, /msg, Adminchat, Mute und Join/Leave",
+        authors = {"MHSL"},
+        dependencies = {@Dependency(id = "luckperms")}
+)
+public final class ChatBridge {
+    /** Backend → Proxy: Rang-Prefixe aus spawn ({@code "prefix"}, danach Adventure-JSON oder leer). */
+    static final ChannelIdentifier CHANNEL = MinecraftChannelIdentifier.create("craftattack", "chat");
+
+    private final ProxyServer proxy;
+    private final Logger logger;
+    private final Path dataDirectory;
+
+    @Inject
+    public ChatBridge(ProxyServer proxy, Logger logger, @DataDirectory Path dataDirectory) {
+        this.proxy = proxy;
+        this.logger = logger;
+        this.dataDirectory = dataDirectory;
+    }
+
+    @Subscribe
+    public void onProxyInitialize(ProxyInitializeEvent event) {
+        Config config;
+        try {
+            config = Config.load(this.dataDirectory);
+        } catch (Exception e) {
+            this.logger.error("Konfiguration ungültig, chat-bridge ist aus", e);
+            return;
+        }
+
+        Names names = new Names(config);
+        Mutes mutes = new Mutes(LuckPermsProvider.get());
+        Chat chat = new Chat(this.proxy, this.logger, config, names, mutes);
+        PrivateMessages privateMessages = new PrivateMessages(this.proxy, this.logger, config, names, chat);
+
+        this.proxy.getChannelRegistrar().register(CHANNEL);
+        this.proxy.getEventManager().register(this, new ChatListener(this, this.proxy, this.logger, names, chat, privateMessages));
+        Commands.register(this, this.proxy, this.logger, config, names, chat, privateMessages, mutes);
+
+        this.logger.info("chat-bridge aktiv, Kürzel {}, ohne Silencer {}", config.serverTags(), config.unsilencedServers());
+    }
+}

src/main/java/eu/mhsl/craftattack/chatbridge/ChatListener.java

@@ -0,0 +1,91 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import com.google.common.io.ByteArrayDataInput;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.connection.DisconnectEvent;
+import com.velocitypowered.api.event.connection.PluginMessageEvent;
+import com.velocitypowered.api.event.player.PlayerChatEvent;
+import com.velocitypowered.api.event.player.ServerPostConnectEvent;
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ProxyServer;
+import com.velocitypowered.api.proxy.ServerConnection;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+import org.slf4j.Logger;
+
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+final class ChatListener {
+    /** Join-Meldung erst nach dieser Zeit, damit das Backend die Rang-Prefixe schon geschickt hat. */
+    private static final long JOIN_DELAY_MS = 1000;
+
+    private final Object plugin;
+    private final ProxyServer proxy;
+    private final Logger logger;
+    private final Names names;
+    private final Chat chat;
+    private final PrivateMessages privateMessages;
+    /** Wer eine Join-Meldung bekommen hat, bekommt beim Verlassen auch eine. */
+    private final Set<UUID> announced = ConcurrentHashMap.newKeySet();
+
+    ChatListener(Object plugin, ProxyServer proxy, Logger logger, Names names, Chat chat, PrivateMessages privateMessages) {
+        this.plugin = plugin;
+        this.proxy = proxy;
+        this.logger = logger;
+        this.names = names;
+        this.chat = chat;
+        this.privateMessages = privateMessages;
+    }
+
+    /**
+     * Nur lesen, nie ablehnen: Eine signierte Nachricht abzulehnen trennt den Spieler. Das Backend
+     * verwirft den Chat selbst.
+     */
+    @Subscribe
+    public void onChat(PlayerChatEvent event) {
+        this.chat.handle(event.getPlayer(), event.getMessage());
+    }
+
+    @Subscribe
+    public void onPluginMessage(PluginMessageEvent event) {
+        if (!event.getIdentifier().equals(ChatBridge.CHANNEL)) return;
+        event.setResult(PluginMessageEvent.ForwardResult.handled());
+        // Nur Backends dürfen Prefixe setzen, ein Client könnte sich sonst einen eigenen geben
+        if (!(event.getSource() instanceof ServerConnection connection)) return;
+
+        try {
+            ByteArrayDataInput in = event.dataAsDataStream();
+            String type = in.readUTF();
+            if (type.equals("prefix")) {
+                String json = in.readUTF();
+                this.names.setPrefix(
+                        connection.getPlayer().getUniqueId(),
+                        connection.getServerInfo().getName(),
+                        json.isEmpty() ? null : GsonComponentSerializer.gson().deserialize(json));
+            }
+        } catch (Exception e) {
+            this.logger.warn("Ungültige Nachricht von {} für {}", connection.getServerInfo().getName(),
+                    connection.getPlayer().getUsername(), e);
+        }
+    }
+
+    @Subscribe
+    public void onServerPostConnect(ServerPostConnectEvent event) {
+        if (event.getPreviousServer() != null) return;
+        Player player = event.getPlayer();
+        this.proxy.getScheduler().buildTask(this.plugin, () -> {
+            if (!player.isActive() || !this.announced.add(player.getUniqueId())) return;
+            this.chat.announceJoin(player);
+        }).delay(JOIN_DELAY_MS, TimeUnit.MILLISECONDS).schedule();
+    }
+
+    @Subscribe
+    public void onDisconnect(DisconnectEvent event) {
+        Player player = event.getPlayer();
+        if (this.announced.remove(player.getUniqueId())) this.chat.announceLeave(player);
+        this.names.forget(player.getUniqueId());
+        this.privateMessages.forget(player.getUniqueId());
+    }
+}

src/main/java/eu/mhsl/craftattack/chatbridge/Commands.java

@@ -0,0 +1,183 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import com.velocitypowered.api.command.CommandManager;
+import com.velocitypowered.api.command.SimpleCommand;
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ProxyServer;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.slf4j.Logger;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+/** Befehle auf dem Proxy; sie greifen vor dem Backend und funktionieren damit auf jedem Server. */
+final class Commands {
+    private Commands() {
+    }
+
+    static void register(Object plugin, ProxyServer proxy, Logger logger, Config config, Names names, Chat chat,
+                         PrivateMessages privateMessages, Mutes mutes) {
+        CommandManager manager = proxy.getCommandManager();
+
+        // tell/w/whisper überdecken die Vanilla-Befehle, die am Mute vorbei flüstern würden
+        manager.register(manager.metaBuilder("msg").aliases("tell", "w", "whisper").plugin(plugin).build(),
+                new PlayerCommand() {
+                    @Override
+                    void run(Player sender, String[] args) {
+                        if (args.length < 2) {
+                            PrivateMessages.error(sender, "Es muss ein Spieler sowie eine Nachricht angegeben werden.");
+                            return;
+                        }
+                        privateMessages.message(sender, args[0], String.join(" ", Arrays.copyOfRange(args, 1, args.length)));
+                    }
+
+                    @Override
+                    public List<String> suggest(Invocation invocation) {
+                        return invocation.arguments().length <= 1 ? playerNames(proxy, invocation.arguments()) : List.of();
+                    }
+                });
+
+        manager.register(manager.metaBuilder("r").plugin(plugin).build(), new PlayerCommand() {
+            @Override
+            void run(Player sender, String[] args) {
+                privateMessages.reply(sender, String.join(" ", args));
+            }
+        });
+
+        manager.register(manager.metaBuilder("adminchat").plugin(plugin).build(), new PlayerCommand() {
+            @Override
+            void run(Player sender, String[] args) {
+                if (args.length == 0) {
+                    PrivateMessages.error(sender, "Syntax: /adminchat <Nachricht>");
+                    return;
+                }
+                String message = String.join(" ", args);
+                Component line = Component.text()
+                        .append(Component.text("[Admin] ", NamedTextColor.LIGHT_PURPLE).clickEvent(ClickEvent.suggestCommand("/adminchat ")))
+                        .append(names.plain(sender))
+                        .append(Component.text(" > ", NamedTextColor.DARK_GRAY))
+                        .append(Component.text(message))
+                        .build();
+                proxy.getAllPlayers().stream()
+                        .filter(player -> player.hasPermission(config.adminPermission()))
+                        .forEach(player -> player.sendMessage(line));
+                logger.info("[adminchat] {}: {}", sender.getUsername(), message);
+            }
+
+            @Override
+            public boolean hasPermission(Invocation invocation) {
+                return invocation.source().hasPermission(config.adminPermission());
+            }
+        });
+
+        manager.register(manager.metaBuilder("mute").plugin(plugin).build(), new SimpleCommand() {
+            @Override
+            public void execute(Invocation invocation) {
+                String[] args = invocation.arguments();
+                int hours;
+                try {
+                    if (args.length < 2) throw new NumberFormatException();
+                    hours = Integer.parseInt(args[1]);
+                    if (hours < 1) throw new NumberFormatException();
+                } catch (NumberFormatException e) {
+                    invocation.source().sendMessage(Component.text("Syntax: /mute <Spieler> <Stunden>", NamedTextColor.RED));
+                    return;
+                }
+                resolve(proxy, mutes, args[0])
+                        .thenCompose(uuid -> mutes.mute(uuid, Duration.ofHours(hours)))
+                        .whenComplete((ignored, error) -> {
+                            if (error != null) {
+                                invocation.source().sendMessage(Component.text("Der Spieler " + args[0] + " ist unbekannt.", NamedTextColor.RED));
+                                return;
+                            }
+                            invocation.source().sendMessage(Component.text(args[0] + " wurde für " + hours + " Stunden gestummt!", NamedTextColor.GREEN));
+                            logger.info("[mute] {} stummt {} für {} h", sourceName(invocation), args[0], hours);
+                        });
+            }
+
+            @Override
+            public List<String> suggest(Invocation invocation) {
+                String[] args = invocation.arguments();
+                if (args.length <= 1) return playerNames(proxy, args);
+                if (args.length == 2) return List.of("1", "2", "4", "8", "24", "48");
+                return List.of();
+            }
+
+            @Override
+            public boolean hasPermission(Invocation invocation) {
+                return invocation.source().hasPermission(config.adminPermission());
+            }
+        });
+
+        manager.register(manager.metaBuilder("unmute").plugin(plugin).build(), new SimpleCommand() {
+            @Override
+            public void execute(Invocation invocation) {
+                String[] args = invocation.arguments();
+                if (args.length != 1) {
+                    invocation.source().sendMessage(Component.text("Syntax: /unmute <Spieler>", NamedTextColor.RED));
+                    return;
+                }
+                resolve(proxy, mutes, args[0])
+                        .thenCompose(mutes::unmute)
+                        .whenComplete((ignored, error) -> {
+                            if (error != null) {
+                                invocation.source().sendMessage(Component.text("Der Spieler " + args[0] + " ist unbekannt.", NamedTextColor.RED));
+                                return;
+                            }
+                            invocation.source().sendMessage(Component.text(args[0] + " ist nicht mehr gestummt.", NamedTextColor.GREEN));
+                            logger.info("[mute] {} hebt Mute von {} auf", sourceName(invocation), args[0]);
+                        });
+            }
+
+            @Override
+            public List<String> suggest(Invocation invocation) {
+                return invocation.arguments().length <= 1 ? playerNames(proxy, invocation.arguments()) : List.of();
+            }
+
+            @Override
+            public boolean hasPermission(Invocation invocation) {
+                return invocation.source().hasPermission(config.adminPermission());
+            }
+        });
+    }
+
+    /** Online zuerst über den Proxy, sonst über LuckPerms (Spieler, die schon mal da waren). */
+    private static CompletableFuture<UUID> resolve(ProxyServer proxy, Mutes mutes, String name) {
+        return proxy.getPlayer(name)
+                .map(player -> CompletableFuture.completedFuture(player.getUniqueId()))
+                .orElseGet(() -> mutes.lookup(name).thenApply(uuid -> {
+                    if (uuid == null) throw new IllegalArgumentException("unbekannt: " + name);
+                    return uuid;
+                }));
+    }
+
+    private static List<String> playerNames(ProxyServer proxy, String[] args) {
+        String start = args.length == 0 ? "" : args[0].toLowerCase(Locale.ROOT);
+        return proxy.getAllPlayers().stream()
+                .map(Player::getUsername)
+                .filter(name -> name.toLowerCase(Locale.ROOT).startsWith(start))
+                .sorted(String.CASE_INSENSITIVE_ORDER)
+                .toList();
+    }
+
+    private static String sourceName(SimpleCommand.Invocation invocation) {
+        return invocation.source() instanceof Player player ? player.getUsername() : "Konsole";
+    }
+
+    /** Befehl nur für Spieler, nicht für die Konsole. */
+    private abstract static class PlayerCommand implements SimpleCommand {
+        abstract void run(Player sender, String[] args);
+
+        @Override
+        public void execute(Invocation invocation) {
+            if (invocation.source() instanceof Player player) run(player, invocation.arguments());
+            else invocation.source().sendMessage(Component.text("Nur für Spieler."));
+        }
+    }
+}

src/main/java/eu/mhsl/craftattack/chatbridge/Config.java

@@ -0,0 +1,69 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Einstellungen aus {@code plugins/chat-bridge/config.properties}. Fehlt die Datei, wird die
+ * kommentierte Vorlage aus dem JAR geschrieben.
+ */
+record Config(
+        Map<String, String> serverTags,
+        Set<String> unsilencedServers,
+        String adminPermission,
+        String markerPermission
+) {
+    static Config load(Path dataDirectory) throws IOException {
+        Path file = dataDirectory.resolve("config.properties");
+        if (Files.notExists(file)) {
+            Files.createDirectories(dataDirectory);
+            try (InputStream template = Config.class.getResourceAsStream("/config.properties")) {
+                if (template == null) throw new IOException("config.properties fehlt im JAR");
+                Files.copy(template, file);
+            }
+        }
+
+        Properties properties = new Properties();
+        try (Reader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
+            properties.load(reader);
+        }
+        return fromProperties(properties);
+    }
+
+    static Config fromProperties(Properties p) {
+        return new Config(
+                pairs(p.getProperty("server-tags", "")),
+                Set.copyOf(split(p.getProperty("unsilenced-servers", ""))),
+                p.getProperty("admin-permission", "admin").trim(),
+                p.getProperty("marker-permission", "adminmarker").trim()
+        );
+    }
+
+    private static Map<String, String> pairs(String value) {
+        Map<String, String> pairs = new HashMap<>();
+        for (String entry : split(value)) {
+            int separator = entry.indexOf('=');
+            if (separator <= 0) throw new IllegalArgumentException("server-tags: '" + entry + "' braucht Server=Kürzel");
+            pairs.put(entry.substring(0, separator).trim(), entry.substring(separator + 1).trim());
+        }
+        return Map.copyOf(pairs);
+    }
+
+    private static List<String> split(String value) {
+        return Arrays.stream(value.split("\\|"))
+                .map(String::trim)
+                .filter(entry -> !entry.isEmpty())
+                .collect(Collectors.toList());
+    }
+}

src/main/java/eu/mhsl/craftattack/chatbridge/Mutes.java

@@ -0,0 +1,77 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import net.luckperms.api.LuckPerms;
+import net.luckperms.api.model.user.User;
+import net.luckperms.api.node.Node;
+import net.luckperms.api.node.NodeType;
+import net.luckperms.api.node.types.PermissionNode;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+
+/**
+ * Mute als zeitlich begrenzte LuckPerms-Permission {@value #NODE}. Liegt damit in der gemeinsamen
+ * MariaDB, gilt auf allen Servern und läuft von selbst ab.
+ */
+final class Mutes {
+    static final String NODE = "chatbridge.muted";
+
+    private final LuckPerms luckPerms;
+
+    Mutes(LuckPerms luckPerms) {
+        this.luckPerms = luckPerms;
+    }
+
+    /** Ende des Mutes eines online Spielers, leer wenn nicht gestummt. */
+    Optional<Instant> mutedUntil(UUID player) {
+        User user = this.luckPerms.getUserManager().getUser(player);
+        if (user == null) return Optional.empty();
+        return user.getNodes(NodeType.PERMISSION).stream()
+                .filter(node -> node.getPermission().equals(NODE) && node.getValue())
+                .filter(node -> node.hasExpiry() && !node.hasExpired())
+                .map(Node::getExpiry)
+                .filter(Objects::nonNull)
+                .max(Instant::compareTo);
+    }
+
+    CompletableFuture<Void> mute(UUID player, Duration duration) {
+        return this.modify(player, user -> {
+            user.data().clear(node -> node.getKey().equals(NODE));
+            user.data().add(PermissionNode.builder(NODE).expiry(duration).build());
+        });
+    }
+
+    CompletableFuture<Void> unmute(UUID player) {
+        return this.modify(player, user -> user.data().clear(node -> node.getKey().equals(NODE)));
+    }
+
+    CompletableFuture<UUID> lookup(String name) {
+        return this.luckPerms.getUserManager().lookupUniqueId(name);
+    }
+
+    private CompletableFuture<Void> modify(UUID player, Consumer<User> action) {
+        User online = this.luckPerms.getUserManager().getUser(player);
+        if (online == null) return this.luckPerms.getUserManager().modifyUser(player, action);
+        action.accept(online);
+        return this.luckPerms.getUserManager().saveUser(online);
+    }
+
+    /** „2 Stunden 5 Minuten“, unter einer Minute „weniger als eine Minute“. */
+    static String format(Duration duration) {
+        long hours = duration.toHours();
+        long minutes = duration.toMinutesPart();
+        if (hours == 0 && minutes == 0) return "weniger als eine Minute";
+        StringBuilder text = new StringBuilder();
+        if (hours > 0) text.append(hours).append(hours == 1 ? " Stunde" : " Stunden");
+        if (minutes > 0) {
+            if (!text.isEmpty()) text.append(' ');
+            text.append(minutes).append(minutes == 1 ? " Minute" : " Minuten");
+        }
+        return text.toString();
+    }
+}

src/main/java/eu/mhsl/craftattack/chatbridge/Names.java

@@ -0,0 +1,78 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ServerConnection;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.event.HoverEvent;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextColor;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Baut den Namen eines Spielers für den Chat: Rang-Prefixe vom Backend, 🎮 für Bedrock und den
+ * Namen, blau für Admins. Die Prefixe schickt das Backend (spawn) über {@link ChatBridge#CHANNEL};
+ * sie gelten nur, solange der Spieler auf genau diesem Server ist.
+ */
+final class Names {
+    private static final TextColor ADMIN = TextColor.color(0x00FFFF);
+
+    private record Prefix(String server, Component component) {
+    }
+
+    private final Config config;
+    private final Map<UUID, Prefix> prefixes = new ConcurrentHashMap<>();
+
+    Names(Config config) {
+        this.config = config;
+    }
+
+    void setPrefix(UUID player, String server, @Nullable Component prefix) {
+        if (prefix == null) this.prefixes.remove(player);
+        else this.prefixes.put(player, new Prefix(server, prefix));
+    }
+
+    void forget(UUID player) {
+        this.prefixes.remove(player);
+    }
+
+    /** Name ohne Klick, z. B. für die eigene Seite einer Privatnachricht. */
+    Component plain(Player player) {
+        TextComponent.Builder name = Component.text();
+
+        Prefix prefix = this.prefixes.get(player.getUniqueId());
+        String server = player.getCurrentServer().map(ServerConnection::getServerInfo).map(info -> info.getName()).orElse(null);
+        if (prefix != null && Objects.equals(prefix.server(), server)) {
+            name.append(prefix.component()).append(Component.space());
+        }
+
+        if (isBedrock(player.getUniqueId())) {
+            name.append(Component.text("🎮", NamedTextColor.GRAY)
+                            .hoverEvent(HoverEvent.showText(Component.text(
+                                    player.getUsername() + " spielt die Minecraft: Bedrock Edition"))))
+                    .append(Component.space());
+        }
+
+        boolean marked = player.hasPermission(this.config.markerPermission());
+        name.append(Component.text(player.getUsername(), marked ? ADMIN : NamedTextColor.WHITE));
+        return name.build();
+    }
+
+    /** Name mit Hover und Klick, der {@code /msg <name>} vorschlägt. */
+    Component clickable(Player player) {
+        return this.plain(player)
+                .hoverEvent(HoverEvent.showText(Component.text("Klicke, um " + player.getUsername() + " zu schreiben", NamedTextColor.GOLD)))
+                .clickEvent(ClickEvent.suggestCommand("/msg " + player.getUsername() + " "));
+    }
+
+    /** Floodgate vergibt Bedrock-Spielern UUIDs, deren obere 64 Bit null sind. */
+    static boolean isBedrock(UUID uuid) {
+        return uuid.getMostSignificantBits() == 0;
+    }
+}

src/main/java/eu/mhsl/craftattack/chatbridge/PrivateMessages.java

@@ -0,0 +1,163 @@
+package eu.mhsl.craftattack.chatbridge;
+
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ProxyServer;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.event.HoverEvent;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * /msg und /r über das ganze Netzwerk. Übernommen aus spawn (PrivateMessage): /r antwortet dem
+ * letzten Gesprächspartner; hat sich das Ziel in den letzten 30 s geändert, wird nachgefragt.
+ */
+final class PrivateMessages {
+    static final int TARGET_CHANGE_TIMEOUT_SECONDS = 30;
+    static final int CONVERSATION_TIMEOUT_MINUTES = 30;
+    private static final Component PREFIX = Component.text("[Privat] ", NamedTextColor.LIGHT_PURPLE);
+
+    private record Conversation(UUID target, String targetName, long lastSet) {
+    }
+
+    private final ProxyServer proxy;
+    private final Logger logger;
+    private final Config config;
+    private final Names names;
+    private final Chat chat;
+    private final Map<UUID, List<Conversation>> replyMapping = new ConcurrentHashMap<>();
+
+    PrivateMessages(ProxyServer proxy, Logger logger, Config config, Names names, Chat chat) {
+        this.proxy = proxy;
+        this.logger = logger;
+        this.config = config;
+        this.names = names;
+        this.chat = chat;
+    }
+
+    void forget(UUID player) {
+        this.replyMapping.remove(player);
+    }
+
+    void reply(Player sender, String message) {
+        List<Conversation> replyList = this.replyMapping.computeIfAbsent(sender.getUniqueId(), uuid -> new ArrayList<>());
+        long now = System.currentTimeMillis();
+
+        synchronized (replyList) {
+            replyList.removeIf(conversation -> conversation.lastSet() < now - CONVERSATION_TIMEOUT_MINUTES * 60_000L);
+            if (replyList.isEmpty()) {
+                error(sender, "Du führst aktuell keine Konversation.");
+                return;
+            }
+
+            Conversation youngest = replyList.stream()
+                    .max(Comparator.comparingLong(Conversation::lastSet))
+                    .orElse(replyList.getLast());
+
+            if (message.isBlank()) {
+                Component current = this.proxy.getPlayer(youngest.target())
+                        .map(this.names::clickable)
+                        .orElse(Component.text("niemandem."));
+                sender.sendMessage(PREFIX.append(Component.text("Du schreibst aktuell mit ", NamedTextColor.GRAY)).append(current));
+                return;
+            }
+
+            List<Conversation> old = replyList.stream()
+                    .filter(conversation -> conversation.lastSet() < now - TARGET_CHANGE_TIMEOUT_SECONDS * 1000L)
+                    .toList();
+
+            if (old.contains(youngest) || replyList.size() == 1) {
+                Player target = this.proxy.getPlayer(youngest.target()).orElse(null);
+                if (target == null) {
+                    error(sender, "Der Spieler " + youngest.targetName() + " ist nicht mehr verfügbar.");
+                    return;
+                }
+                replyList.clear();
+                this.whisper(sender, target, message);
+                return;
+            }
+
+            TextComponent.Builder choice = Component.text()
+                    .append(Component.newline())
+                    .append(PREFIX)
+                    .append(Component.text("Das Ziel für /r hat sich bei dir in den letzten " + TARGET_CHANGE_TIMEOUT_SECONDS
+                            + " Sekunden geändert. Wer soll deine Nachricht erhalten? ", NamedTextColor.RED))
+                    .append(Component.newline())
+                    .append(Component.newline());
+
+            if (!old.isEmpty()) {
+                Conversation youngestOld = old.stream()
+                        .max(Comparator.comparingLong(Conversation::lastSet))
+                        .orElse(old.getLast());
+                replyList.removeAll(old);
+                replyList.add(youngestOld);
+            }
+
+            replyList.stream().map(Conversation::targetName).distinct().forEach(name -> choice
+                    .append(Component.text("[")
+                            .append(Component.text(name, NamedTextColor.GOLD))
+                            .append(Component.text("]"))
+                            .clickEvent(ClickEvent.runCommand("/msg " + name + " " + message))
+                            .hoverEvent(HoverEvent.showText(Component.text("Klicke, um diesem Spieler zu schreiben.", NamedTextColor.GOLD))))
+                    .append(Component.text("  ")));
+            choice.append(Component.newline());
+            sender.sendMessage(choice.build());
+        }
+    }
+
+    void message(Player sender, String targetName, String message) {
+        Player target = this.proxy.getPlayer(targetName).orElse(null);
+        if (target == null) {
+            error(sender, "Der Spieler " + targetName + " konnte nicht gefunden werden.");
+            return;
+        }
+        this.whisper(sender, target, message);
+    }
+
+    private void whisper(Player sender, Player receiver, String message) {
+        // Gestummte dürfen nur noch Admins schreiben
+        if (!receiver.hasPermission(this.config.adminPermission()) && this.chat.denyMuted(sender)) {
+            this.logger.info("[msg] {} -> {} (gestummt): {}", sender.getUsername(), receiver.getUsername(), message);
+            return;
+        }
+
+        long now = System.currentTimeMillis();
+        List<Conversation> receiverList = this.replyMapping.computeIfAbsent(receiver.getUniqueId(), uuid -> new ArrayList<>());
+        synchronized (receiverList) {
+            receiverList.removeIf(conversation -> conversation.target().equals(sender.getUniqueId()));
+            receiverList.add(new Conversation(sender.getUniqueId(), sender.getUsername(), now));
+        }
+        List<Conversation> senderList = new ArrayList<>();
+        senderList.add(new Conversation(receiver.getUniqueId(), receiver.getUsername(), now));
+        this.replyMapping.put(sender.getUniqueId(), senderList);
+
+        sender.sendMessage(Component.text()
+                .append(PREFIX.clickEvent(ClickEvent.suggestCommand("/msg " + receiver.getUsername() + " ")))
+                .append(this.names.plain(sender))
+                .append(Component.text(" zu ", NamedTextColor.GRAY))
+                .append(this.names.clickable(receiver))
+                .append(Component.text(" > ", NamedTextColor.GRAY))
+                .append(Component.text(message)));
+        receiver.sendMessage(Component.text()
+                .append(PREFIX.clickEvent(ClickEvent.suggestCommand("/msg " + sender.getUsername() + " ")))
+                .append(this.names.clickable(sender))
+                .append(Component.text(" zu ", NamedTextColor.GRAY))
+                .append(this.names.plain(receiver))
+                .append(Component.text(" > ", NamedTextColor.GRAY))
+                .append(Component.text(message)));
+
+        this.logger.info("[msg] {} -> {}: {}", sender.getUsername(), receiver.getUsername(), message);
+    }
+
+    static void error(Player player, String message) {
+        player.sendMessage(Component.text(message, NamedTextColor.RED));
+    }
+}