izanmess.
📎 1 file 12,483 chars
📄
pasted-code-1787329727349.txt
txt 624 lines
▶
# Plugin Staff para Velocity + LuckPerms

Quiero desarrollar un plugin de **Staff/Moderación para Minecraft Velocity**, diseñado para funcionar como proxy y administrar jugadores de todos los servidores conectados a la red.

## 1. Tecnologías

* Minecraft: compatible con las versiones modernas soportadas por Velocity.
* Proxy: Velocity.
* Lenguaje: Java.
* Build system: Maven o Gradle.
* API principal: Velocity API.
* Sistema de permisos: LuckPerms.
* El plugin debe funcionar como plugin de Velocity, NO como plugin Bukkit/Paper.
* Código limpio, modular y fácil de ampliar.
* No depender de plugins Bukkit/Paper para las funciones propias del proxy.

## 2. Integración con LuckPerms

Todos los comandos y funciones del plugin deben utilizar **LuckPerms** para comprobar permisos.

No quiero un sistema de permisos propio.

Ejemplos de permisos:

staff.use
staff.help
staff.vanish
staff.chat
staff.alert
staff.freeze
staff.kick
staff.ban
staff.mute
staff.tp
staff.inspect
staff.stafflist
staff.reload
staff.admin

El plugin debe comprobar los permisos mediante la API de LuckPerms.

También quiero que sea posible configurar los permisos utilizados desde un archivo de configuración.

## 3. Sistema de Staff

Crear un sistema completo de staff con diferentes herramientas de moderación.

Comando principal:

/staff

Al ejecutar `/staff`, mostrar un menú o ayuda con las funciones disponibles según los permisos del jugador.

Ejemplos:

/staff help
/staff vanish
/staff chat
/staff list
/staff alert 
/staff freeze 
/staff kick  
/staff mute   
/staff ban   
/staff tp 
/staff inspect 
/staff reload

Un jugador solamente debe poder ejecutar cada comando si tiene el permiso correspondiente.

## 4. Vanish

Implementar un sistema de vanish para Staff.

Comando:

/staff vanish

Cuando un Staff activa vanish:

* Los jugadores normales no deben poder verlo.
* Otros Staff con permiso pueden seguir viéndolo.
* Debe aparecer un mensaje indicando que el vanish está activado/desactivado.
* El estado debe mantenerse al cambiar de servidor dentro del proxy.
* El sistema debe ser compatible con toda la red.
* Los jugadores que entren posteriormente tampoco deben ver al Staff en vanish.
* Si es necesario, implementar la lógica específica de Velocity para ocultar correctamente al jugador de los demás jugadores.

Permisos:

staff.vanish
staff.vanish.see

## 5. Staff Chat

Crear un chat privado para el equipo Staff.

Comando:

/staff chat

También puede existir:

/sc 

Cuando el Staff Chat está activado, los mensajes enviados por el jugador deben llegar solamente a los miembros del Staff que tengan el permiso correspondiente.

Formato configurable:

&8[&bSTAFF&8] &7%player% &8» &f%message%

Permiso:

staff.chat

Debe poder activarse/desactivarse individualmente.

## 6. Alertas globales

Comando:

/staff alert 

Enviar una alerta a todos los Staff conectados a la red.

Formato configurable:

&c&lALERTA &8» &f%message%

También quiero que exista una opción para enviar alertas a todos los jugadores de la red si el Staff tiene un permiso específico.

Permisos:

staff.alert
staff.alert.global

## 7. Freeze

Comando:

/staff freeze 

Congelar a un jugador para impedir que pueda seguir jugando normalmente.

Debe funcionar independientemente del servidor en el que esté conectado el jugador.

Cuando un jugador está congelado:

* Avisarle de que está congelado.
* Mostrar un mensaje configurable.
* Registrar quién lo congeló.
* Impedir que pueda abandonar el servidor si es técnicamente posible mediante Velocity.
* Si abandona, registrar el evento.
* El estado debe almacenarse mientras dure la congelación.

Permiso:

staff.freeze

## 8. Kick

Comando:

/staff kick  

Expulsar al jugador de la red.

El mensaje de expulsión debe ser configurable.

Permiso:

staff.kick

Registrar:

* Staff que ejecutó la acción.
* Jugador afectado.
* Motivo.
* Fecha/hora.
* Servidor en el que estaba.

## 9. Ban

Crear sistema de sanciones.

Ejemplos:

/staff ban  
/staff ban   
/staff unban 

Soportar tiempos como:

30s
10m
2h
1d
7d
30d
permanent

La sanción debe funcionar a nivel de proxy para que el jugador no pueda entrar a ningún servidor de la red.

Guardar:

* UUID.
* Nombre.
* Staff que realizó la sanción.
* Motivo.
* Duración.
* Fecha de inicio.
* Fecha de expiración.
* Si es permanente.

Al intentar entrar un jugador baneado, mostrar una pantalla/mensaje configurable con la información de la sanción.

## 10. Mute

Crear sistema de mute global.

Comandos:

/staff mute   
/staff unmute 

El mute debe aplicarse a toda la red.

Si un jugador muteado intenta hablar, impedir el mensaje y mostrarle cuánto tiempo queda.

Permisos:

staff.mute
staff.unmute

## 11. Teleport

Comando:

/staff tp 

Permitir que un Staff se conecte al servidor donde está otro jugador.

Si ambos están en servidores diferentes:

1. Detectar el servidor del jugador objetivo.
2. Conectar al Staff a ese servidor.
3. Una vez conectado, permitir la lógica necesaria para realizar el teleport.

Permiso:

staff.tp

## 12. Staff List

Comando:

/staff list

Mostrar todos los Staff conectados a la red.

Ejemplo:

&b&lSTAFF ONLINE

&7• &aAdmin &f- &7Lobby
&7• &eMod &f- &7Survival
&7• &eHelper &f- &7Skyblock

La lista debe detectar el servidor actual de cada Staff.

Solamente mostrar jugadores que tengan un permiso configurable, por ejemplo:

staff.stafflist

## 13. Inspección de jugadores

Comando:

/staff inspect 

Mostrar información del jugador:

* Nombre.
* UUID.
* Servidor actual.
* Ping.
* IP, solamente si el sistema y los permisos permiten mostrarla.
* Estado de vanish.
* Estado de mute.
* Estado de ban.
* Estado de freeze.
* Grupo/rango de LuckPerms.
* Fecha de conexión.
* Tiempo conectado.

Permiso:

staff.inspect

La información sensible debe estar protegida mediante permisos.

## 14. Protección contra Staff inferior

El sistema debe poder evitar que un Staff de rango inferior sancione o manipule a uno superior.

Utilizar la información de LuckPerms para comparar la prioridad de los grupos.

Ejemplo:

Owner > Admin > Mod > Helper

Un Moderador no debería poder banear a un Administrador.

Esto debe ser configurable:

staff.protection.enabled=true

Si intenta hacerlo, mostrar:

&cNo puedes realizar esta acción contra este miembro del Staff.

## 15. Registro de acciones

Crear un sistema de logs.

Registrar todas las acciones importantes:

* Ban.
* Unban.
* Mute.
* Unmute.
* Kick.
* Freeze.
* Unfreeze.
* Vanish.
* Alert.
* Teleport.
* Staff Chat.
* Login/logout de Staff.

Formato:

[2026-08-21 18:30:15] [BAN] Staff=Admin Target=Player Reason=Cheating Duration=7d

El sistema debe permitir elegir dónde guardar los logs:

* Consola.
* Archivo.
* Base de datos MySQL/MariaDB opcional.

## 16. Base de datos

Diseñar el plugin para poder utilizar MySQL/MariaDB.

Guardar principalmente:

* Sanciones.
* Mutes.
* Historial de sanciones.
* Datos necesarios del Staff.

La conexión debe ser configurable mediante:

database:
enabled: true
host: localhost
port: 3306
database: staff
username: root
password: password

Las operaciones de base de datos deben ejecutarse de forma asíncrona para no bloquear el hilo principal del proxy.

## 17. Configuración

Crear un `config.yml` completo.

Debe permitir configurar:

* Prefijos.
* Mensajes.
* Formatos.
* Permisos.
* Comandos.
* Duraciones.
* Protección de Staff.
* Base de datos.
* Logs.
* Idioma.
* Debug.

Todos los mensajes deben estar separados de la lógica del código.

## 18. Placeholders

Crear soporte para placeholders en los mensajes.

Por ejemplo:

%player%
%staff%
%server%
%reason%
%duration%
%remaining%
%uuid%
%prefix%
%group%

## 19. Tab completion

Todos los comandos deben tener autocompletado.

Por ejemplo:

/staff ban 

Debe sugerir jugadores conectados.

Para argumentos de tiempo:

/staff ban Player 

Puede sugerir:

30m
1h
1d
7d
30d
permanent

## 20. Seguridad

El plugin debe validar siempre:

* Permisos.
* Jugador objetivo.
* Argumentos.
* Duraciones.
* Motivos.
* Estado del jugador.
* Jerarquía de Staff mediante LuckPerms.

Nunca confiar únicamente en que un jugador tenga acceso al comando principal.

Cada subcomando debe realizar su propia comprobación de permisos.

## 21. Arquitectura

Quiero una arquitectura modular similar a:

com.example.staff
├── StaffPlugin.java
├── command/
├── listener/
├── manager/
├── service/
├── punishment/
├── vanish/
├── chat/
├── database/
├── luckperms/
├── config/
├── utility/
└── model/

Separar correctamente:

* Comandos.
* Eventos.
* Gestión de jugadores.
* Sanciones.
* Vanish.
* LuckPerms.
* Base de datos.
* Configuración.
* Mensajes.

## 22. Eventos de Velocity

Utilizar correctamente los eventos de Velocity para gestionar:

* Login.
* PostLogin.
* Disconnect.
* ServerConnected.
* ServerPreConnect.
* Chat/message events cuando corresponda.
* Cambios de servidor.
* Comandos.

Evitar APIs deprecated y utilizar las APIs actuales de Velocity siempre que sea posible.

## 23. Compatibilidad con LuckPerms

Utilizar la API oficial de LuckPerms para:

* Comprobar permisos.
* Obtener el grupo del jugador.
* Obtener la prioridad del grupo.
* Comparar jerarquías.
* Detectar cambios de permisos cuando sea necesario.

No ejecutar comandos como:

`/lp user ...`

para realizar comprobaciones.

La integración debe realizarse mediante la API de LuckPerms.

## 24. Persistencia

Los estados importantes deben sobrevivir a cambios de servidor.

Por ejemplo:

* Vanish.
* Freeze.
* Mute.
* Ban.
* Staff Chat.

El sistema debe utilizar UUID como identificador principal, no solamente el nombre del jugador.

## 25. Rendimiento

El plugin debe estar optimizado para redes grandes.

No hacer consultas MySQL constantemente.

Utilizar:

* Caché en memoria.
* Operaciones asíncronas.
* Consultas preparadas.
* Connection pooling si se utiliza MySQL.
* Limpieza de caché.
* Evitar tareas repetitivas innecesarias.

## 26. Mensajes

Todos los mensajes deben ser configurables y soportar colores de Minecraft.

Ejemplo:

prefix: "&8[&bStaff&8]"

messages:
no-permission: "%prefix% &cNo tienes permiso."
player-not-found: "%prefix% &cJugador no encontrado."
vanish-enabled: "%prefix% &aVanish activado."
vanish-disabled: "%prefix% &cVanish desactivado."
staff-chat: "&8[&bSTAFF&8] &7%player% &8» &f%message%"
frozen: "&cHas sido congelado por un Staff."
target-already-banned: "%prefix% &cEse jugador ya está baneado."

## 27. Comando reload

Comando:

/staff reload

Recargar configuración sin reiniciar Velocity.

Permiso:

staff.reload

No reiniciar ni desconectar jugadores.

## 28. Comandos finales

Como mínimo quiero:

/staff
/staff help
/staff vanish
/staff chat
/staff list
/staff alert
/staff freeze
/staff unfreeze
/staff kick
/staff ban
/staff unban
/staff mute
/staff unmute
/staff tp
/staff inspect
/staff reload

También permitir aliases configurables.

## 29. Entrega del proyecto

Genera el proyecto completo y funcional, no solamente ejemplos.

Necesito:

* `pom.xml` o `build.gradle`.
* Clase principal.
* `velocity-plugin.json`.
* Todos los comandos.
* Todos los listeners.
* Managers.
* Integración LuckPerms.
* Configuración.
* Sistema de mensajes.
* Sistema de sanciones.
* Sistema de logs.
* Persistencia.
* MySQL/MariaDB.
* Tab completion.
* Manejo de errores.
* README con instrucciones de instalación.

El resultado debe poder compilarse directamente y generar el `.jar` del plugin.

Antes de escribir el código, revisa la API actual de Velocity y LuckPerms y utiliza las versiones compatibles más recientes. No inventes métodos de las APIs.

Quiero que el código esté preparado para producción y que no sea simplemente un ejemplo básico.
Kodari AI
KodariAug 21 at 4:36 pm 4
  1. Crear la base Maven de Velocity con metadatos, configuración y README.

  2. Implementar servicios modulares para configuración, mensajes, LuckPerms, caché de jugadores, sanciones, vanish, chat y persistencia MySQL.

  3. Añadir comandos /staff y /sc con permisos independientes, validación, protección jerárquica y tab completion.

  4. Registrar listeners de conexión, chat, cambios de servidor y desconexión, además del sistema de logs y recarga.

Proyecto generado como plugin de Velocity + LuckPerms, con:

  • Maven, velocity-plugin.json, manifest.kod, configuración completa y README.

  • Comandos /staff y /sc con permisos configurables y tab completion.

  • Vanish a nivel de tablist del proxy.

  • Staff Chat, alertas staff/globales, freeze, kick, ban, mute, teleport e inspección.

  • Protección jerárquica mediante pesos de grupos de LuckPerms.

  • Persistencia opcional MySQL/MariaDB con operaciones asíncronas y pool HikariCP.

  • Logs en consola y archivo.

  • Mensajes configurables con colores y placeholders.

  • Eventos de login, desconexión, conexión a servidores, chat y cambios de servidor.

  • Recarga de configuración sin reiniciar el proxy.

La ocultación de entidades dentro del mundo y el bloqueo físico de movimiento durante freeze requieren soporte adicional en los servidores backend; Velocity controla aquí la visibilidad de tablist y el estado global de moderación.

Kodari can make mistakes. Review important code before using.
Files
src
manifest.kod
pom.xml
README.md
Code
22 1,439
src/main/java/com/example/staff/command/StaffCommand.java
package com.example.staff.command;

import com.example.staff.config.ConfigManager;
import com.example.staff.luckperms.LuckPermsService;
import com.example.staff.manager.NetworkPlayerManager;
import com.example.staff.manager.PunishmentManager;
import com.example.staff.model.Punishment;
import com.example.staff.model.PunishmentType;
import com.example.staff.service.ActionLogger;
import com.example.staff.service.MessageService;
import com.example.staff.service.NetworkStateService;
import com.example.staff.utility.DurationParser;
import com.example.staff.utility.TextUtil;
import com.velocitypowered.api.command.CommandSource;
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 java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;

public class StaffCommand implements SimpleCommand {
    private final ProxyServer proxy;
    private final ConfigManager config;
    private final MessageService messages;
    private final LuckPermsService luckPerms;
    private final NetworkPlayerManager players;
    private final PunishmentManager punishments;
    private final NetworkStateService state;
    private final ActionLogger logger;

    public StaffCommand(ProxyServer proxy, ConfigManager config, MessageService messages, LuckPermsService luckPerms, NetworkPlayerManager players, PunishmentManager punishments, NetworkStateService state, ActionLogger logger) {
        this.proxy = proxy;
        this.config = config;
        this.messages = messages;
        this.luckPerms = luckPerms;
        this.players = players;
        this.punishments = punishments;
        this.state = state;
        this.logger = logger;
    }

    @Override
    public void execute(Invocation invocation) {
        String[] args = invocation.arguments();
        if (args.length == 0) {
            if (check(invocation.source(), "use")) help(invocation.source());
            return;
        }
        String subcommand = args[0].toLowerCase();
        try {
            switch (subcommand) {
                case "help" -> { if (check(invocation.source(), "help")) help(invocation.source()); }
                case "vanish" -> vanish(invocation.source());
                case "chat" -> chat(invocation.source());
                case "list" -> list(invocation.source());
                case "alert" -> alert(invocation.source(), args);
                case "freeze" -> freeze(invocation.source(), args, false);
                case "unfreeze" -> freeze(invocation.source(), args, true);
                case "kick" -> kick(invocation.source(), args);
                case "ban" -> ban(invocation.source(), args);
                case "unban" -> removePunishment(invocation.source(), args, PunishmentType.BAN);
                case "mute" -> mute(invocation.source(), args);
                case "unmute" -> removePunishment(invocation.source(), args, PunishmentType.MUTE);
                case "tp" -> teleport(invocation.source(), args);
                case "inspect" -> inspect(invocation.source(), args);
                case "reload" -> reload(invocation.source());
                default -> messages.send(invocation.source(), "messages.usage", Collections.emptyMap());
            }
        } catch (Exception exception) {
            logger.log("ERROR", invocation.source().toString(), "-", "Command=" + subcommand + " Error=" + exception.getClass().getSimpleName());
            messages.send(invocation.source(), "messages.command-error", Collections.emptyMap());
        }
    }

    private void help(CommandSource source) {
        source.sendMessage(messages.render("messages.help-header", Collections.emptyMap()));
        String[][] entries = {{"help", "help", "Mostrar esta ayuda"}, {"vanish", "vanish", "Alternar vanish"}, {"chat", "chat", "Alternar Staff Chat"}, {"list", "stafflist", "Ver staff conectado"}, {"alert <mensaje>", "alert", "Enviar una alerta"}, {"freeze <jugador>", "freeze", "Congelar un jugador"}, {"unfreeze <jugador>", "unfreeze", "Descongelar un jugador"}, {"kick <jugador> <motivo>", "kick", "Expulsar un jugador"}, {"ban <jugador> [tiempo] <motivo>", "ban", "Banear un jugador"}, {"unban <jugador>", "unban", "Retirar un ban"}, {"mute <jugador> <tiempo> <motivo>", "mute", "Mutear un jugador"}, {"unmute <jugador>", "unmute", "Retirar un mute"}, {"tp <jugador>", "tp", "Conectar con su servidor"}, {"inspect <jugador>", "inspect", "Inspeccionar un jugador"}, {"reload", "reload", "Recargar configuración"}};
        for (String[] entry : entries) {
            if (source instanceof Player player && !luckPerms.hasPermission(player, config.permission(entry[1]))) continue;
            Map<String, String> values = Map.of("command", entry[0], "description", entry[2]);
            source.sendMessage(messages.render("messages.help-line", values));
        }
        source.sendMessage(messages.render("messages.help-footer", Collections.emptyMap()));
    }

    private void vanish(CommandSource source) {
        if (!(source instanceof Player player)) { playerOnly(source); return; }
        if (!check(player, "vanish")) return;
        boolean enabled = state.toggleVanish(player);
        messages.send(player, enabled ? "messages.vanish-enabled" : "messages.vanish-disabled", Collections.emptyMap());
        logger.log("VANISH", player.getUsername(), player.getUsername(), "Enabled=" + enabled);
    }

    private void chat(CommandSource source) {
        if (!(source instanceof Player player)) { playerOnly(source); return; }
        if (!check(player, "chat")) return;
        boolean enabled = state.toggleStaffChat(player.getUniqueId());
        messages.send(player, enabled ? "messages.staff-chat-enabled" : "messages.staff-chat-disabled", Collections.emptyMap());
    }

    private void list(CommandSource source) {
        if (!check(source, "stafflist")) return;
        source.sendMessage(messages.render("messages.staff-list-header", Collections.emptyMap()));
        for (Player player : players.online()) {
            if (!luckPerms.hasPermission(player, config.permission("stafflist"))) continue;
            source.sendMessage(messages.render("messages.staff-list-line", Map.of("player", player.getUsername(), "server", players.server(player))));
        }
    }

    private void alert(CommandSource source, String[] args) {
        if (!check(source, "alert")) return;
        if (args.length < 2) { messages.send(source, "messages.reason-required", Collections.emptyMap()); return; }
        String message = join(args, 1);
        boolean global = source instanceof Player player && luckPerms.hasPermission(player, config.permission("alert-global"));
        Component component = messages.render(global ? "formats.global-alert" : "formats.alert", Map.of("message", message));
        if (global) players.online().forEach(player -> player.sendMessage(component));
        else players.online().stream().filter(player -> luckPerms.hasPermission(player, config.permission("alert"))).forEach(player -> player.sendMessage(component));
        proxy.getConsoleCommandSource().sendMessage(component);
        messages.send(source, "messages.alert-sent", Collections.emptyMap());
        logger.log("ALERT", actorName(source), "-", "Global=" + global + " Message=" + message);
    }

    private void freeze(CommandSource source, String[] args, boolean unfreeze) {
        if (!check(source, unfreeze ? "unfreeze" : "freeze")) return;
        if (args.length < 2) { messages.send(source, "messages.player-not-found", Collections.emptyMap()); return; }
        Optional<Player> target = players.find(args[1]);
        if (target.isEmpty()) { messages.send(source, "messages.player-not-found", Collections.emptyMap()); return; }
        if (!protect(source, target.get())) return;
        if (unfreeze) {
            if (state.unfreeze(target.get().getUniqueId()) == null) { messages.send(source, "messages.not-frozen", Collections.emptyMap()); return; }
            messages.send(source, "messages.unfreeze-success", Map.of("player", target.get().getUsername()));
            logger.log("UNFREEZE", actorName(source), target.get().getUsername(), "Server=" + players.server(target.get()));
        } else {
            state.freeze(target.get().getUniqueId(), source instanceof Player player ? player.getUniqueId() : null, actorName(source));
            target.get().sendMessage(messages.render("messages.frozen", Map.of("staff", actorName(source))));
            messages.send(source, "messages.freeze-success", Map.of("player", target.get().getUsername()));
            logger.log("FREEZE", actorName(source), target.get().getUsername(), "Server=" + players.server(target.get()));
        }
    }

    private void kick(CommandSource source, String[] args) {
        if (!check(source, "kick")) return;
        if (args.length < 3) { messages.send(source, "messages.reason-required", Collections.emptyMap()); return; }
        Optional<Player> target = players.find(args[1]);
        if (target.isEmpty()) { messages.send(source, "messages.player-not-found", Collections.emptyMap()); return; }
        if (!protect(source, target.get())) return;
        String reason = join(args, 2);
        target.get().disconnect(messages.render("messages.kicked", Map.of("staff", actorName(source), "reason", reason)));
        messages.send(source, "messages.kick-success", Map.of("player", target.get().getUsername()));
        logger.log("KICK", actorName(source), target.get().getUsername(), "Reason=" + reason + " Server=" + players.server(target.get()));
    }

    private void ban(CommandSource source, String[] args) {
        if (!check(source, "ban")) return;
        if (args.length < 3) { messages.send(source, "messages.reason-required", Collections.emptyMap()); return; }
        Optional<Player> optionalTarget = players.find(args[1]);
        if (optionalTarget.isEmpty()) { messages.send(source, "messages.player-not-found", Collections.emptyMap()); return; }
        Player target = optionalTarget.get();
        if (!protect(source, target)) return;
        if (punishments.getBan(target.getUniqueId()) != null) { messages.send(source, "messages.already-banned", Collections.emptyMap()); return; }
        DurationAndReason parsed = durationAndReason(args, 2);
        if (parsed == null) return;
        if (parsed.reason.isBlank()) { messages.send(source, "messages.reason-required", Collections.emptyMap()); return; }
        Punishment punishment = punishments.create(target.getUniqueId(), target.getUsername(), source instanceof Player player ? player.getUniqueId() : null, actorName(source), PunishmentType.BAN, parsed.reason, parsed.duration);
        target.disconnect(messages.render("messages.banned", Map.of("reason", parsed.reason, "duration", punishment.durationText(), "remaining", punishment.isPermanent() ? "permanent" : TextUtil.formatDuration(Duration.between(Instant.now(), punishment.getExpiresAt())))));
        messages.send(source, "messages.ban-success", Map.of("player", target.getUsername(), "duration", punishment.durationText()));
        logger.log("BAN", actorName(source), target.getUsername(), "Reason=" + parsed.reason + " Duration=" + punishment.durationText() + " Server=" + players.server(target));
    }

    private void mute(CommandSource source, String[] args) {
        if (!check(source, "mute")) return;
        if (args.length < 4) { messages.send(source, "messages.reason-required", Collections.emptyMap()); return; }
        Optional<Player> optionalTarget = players.find(args[1]);
        if (optionalTarget.isEmpty()) { messages.send(source, "messages.player-not-found", Collections.emptyMap()); return; }
        Player target = optionalTarget.get();
        if (!protect(source, target)) return;
        if (punishments.getMute(target.getUniqueId()) != null) { messages.send(source, "messages.already-muted", Collections.emptyMap()); return; }
        Duration duration = DurationParser.isPermanent(args[2]) ? null : DurationParser.parse(args[2]).orElse(null);
        if (duration == null && !DurationParser.isPermanent(args[2])) { messages.send(source, "messages.invalid-duration", Collections.emptyMap()); return; }
        String reason = join(args, 3);
        Punishment punishment = punishments.create(target.getUniqueId(), target.getUsername(), source instanceof Player player ? player.getUniqueId() : null, actorName(source), PunishmentType.MUTE, reason, duration);
        messages.send(source, "messages.mute-success", Map.of("player", target.getUsername(), "duration", punishment.durationText()));
        logger.log("MUTE", actorName(source), target.getUsername(), "Reason=" + reason + " Duration=" + punishment.durationText());
    }

    private void removePunishment(CommandSource source, String[] args, PunishmentType type) {
        if (!check(source, type == PunishmentType.BAN ? "unban" : "unmute")) return;
        if (args.length < 2) { messages.send(source, "messages.player-not-found", Collections.emptyMap()); return; }
        Optional<Player> target = players.find(args[1]);