dokončen reply command

pom.xml

@@ -61,6 +61,36 @@
                             </execution>
                         </executions>
                     </plugin>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-shade-plugin</artifactId>
+                        <version>3.2.4</version>
+                        <configuration>
+                            <relocations>
+                                <relocation>
+                                    <pattern>dev.dejvokep.boostedyaml.*</pattern>
+                                    <shadedPattern>xyz.soukup.boostedYaml</shadedPattern>
+                                </relocation>
+                            </relocations>
+                        </configuration>
+                        <executions>
+                            <execution>
+                                <phase>package</phase>
+                                <goals>
+                                    <goal>shade</goal>
+                                </goals>
+                                <configuration>
+                                    <artifactSet>
+                                        <includes>
+                                            <include>dev.dejvokep:boosted-yaml</include>
+                                            <!-- If also implementing the boosted-yaml-spigot, add this: -->
+                                            <include>dev.dejvokep:boosted-yaml-spigot</include>
+                                        </includes>
+                                    </artifactSet>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
                 </plugins>
                 <resources>
                     <resource>
@@ -160,5 +190,10 @@
             <version>3.4.0-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>dev.dejvokep</groupId>
+            <artifactId>boosted-yaml</artifactId>
+            <version>1.3.5</version>
+        </dependency>
     </dependencies>
 </project>

src/main/java/xyz/soukup/ecocraftVelocity/EcocraftVelocity.java

@@ -8,13 +8,25 @@ import com.velocitypowered.api.event.EventManager;
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.event.Subscribe;
 import com.velocitypowered.api.plugin.Plugin;
+import com.velocitypowered.api.plugin.annotation.DataDirectory;
 import com.velocitypowered.api.proxy.ProxyServer;
+import dev.dejvokep.boostedyaml.YamlDocument;
 import org.slf4j.Logger;
 import xyz.soukup.ecocraftVelocity.chat.DirectMessages;
 import xyz.soukup.ecocraftVelocity.chat.GlobalChat;
 import xyz.soukup.ecocraftVelocity.chat.JoinLeaveMessages;
+import xyz.soukup.ecocraftVelocity.chat.ReplyCommand;
+import xyz.soukup.ecocraftVelocity.configuration.LangManager;
+import xyz.soukup.ecocraftVelocity.motd.MotdRequestEvent;
 import xyz.soukup.ecocraftVelocity.tab.GlobalTab;
 
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Objects;
+
 @Plugin(id = "ecocraftvelocity", name = "EcocraftVelocity", version = "1.0-SNAPSHOT")
 public class EcocraftVelocity {
 
@@ -24,29 +36,76 @@ public class EcocraftVelocity {
     @Inject
     private ProxyServer server;
 
+    @Inject
+    @DataDirectory
+    private Path dataDirectory;
+
+    private YamlDocument config;
+    private YamlDocument lang;
+    private LangManager langManager;
+
     @Subscribe
     public void onProxyInitialization(ProxyInitializeEvent event) {
         logger.info("Startujeme!");
+        setupConfigs();
+        loadResources();
         registerEvents();
         registerCommands();
     }
-;
+
     private void registerEvents(){
         EventManager eventManager = server.getEventManager();
-        eventManager.register(this, new GlobalChat(server));
+        eventManager.register(this, new GlobalChat(server, langManager));
-        eventManager.register(this, new GlobalTab(server));
+        eventManager.register(this, new GlobalTab(server, langManager));
-        eventManager.register(this, new JoinLeaveMessages(server));
+        eventManager.register(this, new JoinLeaveMessages(server, langManager));
+        eventManager.register(this, new MotdRequestEvent(langManager, dataDirectory));
     }
 
     private void registerCommands(){
-        CommandManager commandManager = server.getCommandManager();
+        registerCommand("msg", new DirectMessages(server, langManager).command());
+        registerCommand("r", new ReplyCommand(langManager).command(server));
+    }
 
-        CommandMeta commandMeta = commandManager.metaBuilder("msg")
+    private void registerCommand(String name, BrigadierCommand command){
+        CommandManager commandManager = server.getCommandManager();
+        CommandMeta commandMeta = commandManager.metaBuilder(name)
                 .plugin(this)
                 .build();
 
-        BrigadierCommand commandToRegister = DirectMessages.messageCommand(server);
+        commandManager.register(commandMeta, command);
+    }
 
-        commandManager.register(commandMeta, commandToRegister);
+    private void setupConfigs(){
+        try {
+            config = YamlDocument.create(new File(dataDirectory.toFile(), "config.yml"), Objects.requireNonNull(this.getClass().getResourceAsStream("/config.yml")));
+            lang = YamlDocument.create(new File(dataDirectory.toFile(), "messages.yml"), Objects.requireNonNull(this.getClass().getResourceAsStream("/messages.yml")));
+            langManager = new LangManager(lang);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
         }
     }
+
+    private void loadResources(){
+        loadResource("server-icon.png");
+    }
+
+    private void loadResource(String relativePath){
+        try {
+            Path target = dataDirectory.resolve(relativePath);
+
+            if (Files.exists(target)) {
+                return;
+            }
+
+            Files.createDirectories(dataDirectory);
+            InputStream in = getClass().getClassLoader().getResourceAsStream(relativePath);
+
+            assert in != null;
+            Files.copy(in, target);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+}

src/main/java/xyz/soukup/ecocraftVelocity/chat/DirectMessages.java

@@ -12,32 +12,42 @@ import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
-import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import xyz.soukup.ecocraftVelocity.configuration.LangManager;
+import xyz.soukup.ecocraftVelocity.configuration.Replace;
 
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
 public class DirectMessages {
-    public static BrigadierCommand messageCommand(final ProxyServer proxy) {
+
+    private final ProxyServer proxy;
+    private final LangManager langManager;
+
+    public DirectMessages(ProxyServer proxyServer, LangManager langManager) {
+        this.proxy = proxyServer;
+        this.langManager = langManager;
+    }
+
+    public  BrigadierCommand command() {
         LiteralCommandNode<CommandSource> msg = BrigadierCommand.literalArgumentBuilder("msg")
                 .then(BrigadierCommand.requiredArgumentBuilder("player", StringArgumentType.word())
-                        .suggests((ctx, builder) -> playerSuggestor(proxy, ctx, builder))
+                        .suggests(this::playerSuggestor)
                         .then(BrigadierCommand.requiredArgumentBuilder("message", StringArgumentType.greedyString())
-                                .executes((ctx) -> sendDirectMessage(proxy, ctx)))
+                                .executes(this::sendDirectMessage))
                 )
                 .build();
 
         return new BrigadierCommand(msg);
     }
 
-    private static CompletableFuture<Suggestions> playerSuggestor(ProxyServer proxy, CommandContext<CommandSource> ctx, SuggestionsBuilder builder) {
+    private CompletableFuture<Suggestions> playerSuggestor( CommandContext<CommandSource> ctx, SuggestionsBuilder builder) {
         proxy.getAllPlayers().forEach(player -> {
             builder.suggest(player.getUsername());
         });
         return builder.buildFuture();
     }
 
-    private static int sendDirectMessage(ProxyServer proxy, CommandContext<CommandSource> context) {
+    private int sendDirectMessage(CommandContext<CommandSource> context) {
         String playerName = context.getArgument("player", String.class);
         String message = context.getArgument("message", String.class);
         MiniMessage mm = MiniMessage.miniMessage();
@@ -48,24 +58,25 @@ public class DirectMessages {
 
         if (playerOptional.isEmpty()){
             sender.sendMessage(mm.deserialize("<red>Není online."));
-            return Command.SINGLE_SUCCESS;
+            return 1;
         }
 
 
-        String senderFormat = "<hover:show_text:\"<yellow><bold><name></bold><br><white>Klikni pro odepsání\"><click:suggest_command:\"/msg " + playerName + " \">" +
-                "<blue>já <white><bold>▶ </bold><blue><name></click></hover>" +
-                "<gray>: <white><msg>";
 
+        Component senderMessage = langManager.get("chat-format.direct.sender",
+                new Replace("msg", message, sender.hasPermission("ecocraft.chat.formatting")),
+                new Replace("name", playerName));
 
 
-        sender.sendMessage(mm.deserialize(senderFormat, Placeholder.unparsed("msg", message), Placeholder.unparsed("name", playerName)));
+        sender.sendMessage(senderMessage);
 
         proxy.getPlayer(playerName).ifPresent(player ->
                 {
-                    String receiverFormat = "<hover:show_text:\"<yellow><bold><name></bold><br><white>Klikni pro odepsání\"><click:suggest_command:\"/msg " + sender.getUsername() + " \">" +
+                    Component receiverMessage = langManager.get("chat-format.direct.receiver",
-                            "<blue><name> <white><bold>▶ </bold><blue>já</click></hover>" +
+                            new Replace("msg", message, sender.hasPermission("ecocraft.chat.formatting")),
-                            "<gray>: <white><msg>";
+                            new Replace("name", sender.getUsername()));
-                    player.sendMessage(mm.deserialize(receiverFormat, Placeholder.unparsed("msg", message), Placeholder.unparsed("name", sender.getUsername())));
+                    player.sendMessage(receiverMessage);
+                    ReplyCommand.addRecipient(player, sender);
                 }
         );
         return Command.SINGLE_SUCCESS;

src/main/java/xyz/soukup/ecocraftVelocity/chat/GlobalChat.java

@@ -5,16 +5,17 @@ import com.velocitypowered.api.event.player.PlayerChatEvent;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.minimessage.MiniMessage;
+import xyz.soukup.ecocraftVelocity.configuration.LangManager;
-import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import xyz.soukup.ecocraftVelocity.configuration.Replace;
 
 public class GlobalChat {
 
     private final ProxyServer server;
-    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+    private final LangManager langManager;
 
-    public GlobalChat(ProxyServer server){
+    public GlobalChat(ProxyServer server, LangManager langManager){
         this.server = server;
+        this.langManager = langManager;
     }
 
     @Subscribe
@@ -22,29 +23,21 @@ public class GlobalChat {
         //noinspection deprecation
         event.setResult(PlayerChatEvent.ChatResult.denied());
 
-        String message = event.getMessage();
+        String text = event.getMessage();
         Player player = event.getPlayer();
 
-        server.sendMessage(prepareMessageComponent(message, player));
+        Component message = langManager.get(
-
+                "chat-format.player-message",
-
+                new Replace("name", player.getUsername()),
+                new Replace("msg", text, player.hasPermission("ecocraft.chat.formatting"))
+        );
 
+        server.sendMessage(message);
 
 
-    }
 
-    private static Component prepareMessageComponent(String text, Player player){
-        final MiniMessage miniMessage = MiniMessage.miniMessage();
 
-        String format = "<hover:show_text:'<yellow><bold><name><br><white>Klikni pro napsání hráči'><click:suggest_command:/msg <name> >" +
-                "<yellow><bold><name></click></hover>" +
-                ": <white><msg>";
 
-
-        return miniMessage.deserialize(
-                format,
-                Placeholder.parsed("name", player.getUsername()),
-                Placeholder.unparsed("msg", text)
-        );
     }
+
 }

src/main/java/xyz/soukup/ecocraftVelocity/chat/JoinLeaveMessages.java

@@ -7,32 +7,31 @@ import com.velocitypowered.api.event.player.ServerPostConnectEvent;
 import com.velocitypowered.api.proxy.ProxyServer;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import xyz.soukup.ecocraftVelocity.configuration.LangManager;
+import xyz.soukup.ecocraftVelocity.configuration.Replace;
 
 public class JoinLeaveMessages {
 
     private final ProxyServer server;
-    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+    private final LangManager langManager;
 
-    public JoinLeaveMessages(ProxyServer server){
+    public JoinLeaveMessages(ProxyServer server, LangManager langManager){
         this.server = server;
+        this.langManager = langManager;
     }
 
     @Subscribe
     public void onJoin(LoginEvent event){
         String name = event.getPlayer().getUsername();
 
-        String messageFormat = "<gray>[<green>+<gray>] <name>";
+        server.sendMessage(langManager.get("chat-format.join", new Replace("name", name)));
-
-        server.sendMessage(miniMessage.deserialize(messageFormat, Placeholder.parsed("name", name)));
     }
 
     @Subscribe
     public void onLeave(DisconnectEvent event){
         String name = event.getPlayer().getUsername();
 
-        String messageFormat = "<gray>[<red>-<gray>] <name>";
+        server.sendMessage(langManager.get("chat-format.leave", new Replace("name", name)));
-
-        server.sendMessage(miniMessage.deserialize(messageFormat, Placeholder.parsed("name", name)));
     }
 
 }

src/main/java/xyz/soukup/ecocraftVelocity/chat/Recipients.java

@@ -0,0 +1,55 @@
+package xyz.soukup.ecocraftVelocity.chat;
+
+import com.velocitypowered.api.proxy.Player;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class Recipients {
+    HashMap<Player, Instant> recipients;
+
+    public Recipients() {
+        this.recipients = new HashMap<>();
+    }
+
+    public void add(Player player){
+        recipients.put(player, Instant.now());
+    }
+
+
+    public List<Player> getPlayers(){
+        List<Player> players = new ArrayList<>();
+        Instant lastEligibleInstant = Instant.now().minus(Duration.ofMinutes(5));
+
+        recipients.forEach((player, date) -> {
+                if (date.isBefore(lastEligibleInstant) || !player.isActive()){
+                    recipients.remove(player);
+                }else {
+                    players.add(player);
+                }
+        });
+
+        return players;
+    }
+
+    public List<String> getUsernames(){
+        List<String> usernames = new ArrayList<>();
+
+        for (Player player : getPlayers()){
+            usernames.add(player.getUsername());
+        }
+
+        return usernames;
+    }
+
+    public int count(){
+        return getPlayers().size();
+    }
+
+    public Player getFirst(){
+        return getPlayers().get(0);
+    }
+}

src/main/java/xyz/soukup/ecocraftVelocity/chat/ReplyCommand.java

@@ -1,6 +1,5 @@
 package xyz.soukup.ecocraftVelocity.chat;
 
-import com.mojang.brigadier.Command;
 import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.tree.LiteralCommandNode;
@@ -8,29 +7,95 @@ import com.velocitypowered.api.command.BrigadierCommand;
 import com.velocitypowered.api.command.CommandSource;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import xyz.soukup.ecocraftVelocity.configuration.LangManager;
+import xyz.soukup.ecocraftVelocity.configuration.Replace;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
 public class ReplyCommand {
 
-    public static HashMap<CommandSource, List<Player>> replyRecipients = new HashMap<>();
+    public static HashMap<Player, Recipients> replyRecipients = new HashMap<>();
 
-    public static BrigadierCommand replyCommand(final ProxyServer proxy){
+    private final LangManager langManager;
+
+    public ReplyCommand(LangManager langManager){
+        this.langManager = langManager;
+    }
+
+    public BrigadierCommand command(final ProxyServer proxy){
         LiteralCommandNode<CommandSource> reply = BrigadierCommand.literalArgumentBuilder("r")
                 .then(BrigadierCommand.requiredArgumentBuilder("message", StringArgumentType.greedyString())
-                        .executes(ReplyCommand::reply)
+                        .executes((context -> reply(context, langManager)))
                 )
                 .build();
 
         return new BrigadierCommand(reply);
     }
 
-    private static int reply(CommandContext<CommandSource> ctx){
+    private static int reply(CommandContext<CommandSource> ctx, LangManager langManager){
         String message = ctx.getArgument("message", String.class);
-        List<Player> recipients = replyRecipients.get(ctx.getSource());
+        Player sender = (Player) ctx.getSource();
+        Recipients recipients = replyRecipients.computeIfAbsent(sender, k -> new Recipients());
+
+        switch (recipients.count()){
+            case 0:
+                langManager.send("chat-format.direct.reply.error.no-recipients", sender);
+                break;
+            case 1:
+                sendDirectMessage(langManager, sender, recipients.getFirst(), message);
+                break;
+            default:
+                sendPlayerSelector(langManager, sender, recipients, message);
+        }
+
         return 0;
     }
 
+    private static void sendDirectMessage(LangManager langManager, Player sender, Player receiver, String message){
+        langManager.send("chat-format.direct.sender", sender,
+                new Replace("name", receiver.getUsername()),
+                new Replace("msg", message));
+        langManager.send("chat-format.direct.receiver", receiver,
+                new Replace("name", sender.getUsername()),
+                new Replace("msg", message));
+        addRecipient(sender, receiver);
+    }
+
+    private static void sendPlayerSelector(LangManager langManager, Player sender, Recipients recipients, String message){
+        List<String> recipientsUsernames = recipients.getUsernames();
+        List<Component> formatedRecipientsUsernames = new ArrayList<>();
+
+        for (String username : recipientsUsernames){
+            Component formatedUsername = langManager.get("chat-format.direct.reply.multiple-receivers.name-format",
+                    new Replace("name", username),
+                    new Replace("msg", message));
+            formatedRecipientsUsernames.add(formatedUsername);
+        }
+
+        Component prefix = langManager.get("chat-format.direct.reply.multiple-receivers.prefix");
+
+        JoinConfiguration joinConfiguration = JoinConfiguration.separator(langManager.get("chat-format.direct.reply.multiple-receivers.separator"));
+        Component selector = Component.join(joinConfiguration,formatedRecipientsUsernames);
+
+        Component suffix = langManager.get("");
+
+        sender.sendMessage(prefix.append(selector).append(suffix));
+    }
+
+
+
+    public static void addRecipient(Player player1, Player player2){
+        Recipients recipients1 = replyRecipients.computeIfAbsent(player1, k -> new Recipients());
+        Recipients recipients2 = replyRecipients.computeIfAbsent(player2, k -> new Recipients());
+
+        recipients1.add(player2);
+        recipients2.add(player1);
+
+    }
+
 
 }

src/main/java/xyz/soukup/ecocraftVelocity/configuration/LangManager.java

@@ -0,0 +1,74 @@
+package xyz.soukup.ecocraftVelocity.configuration;
+
+import com.velocitypowered.api.proxy.Player;
+import dev.dejvokep.boostedyaml.YamlDocument;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentBuilder;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+import javax.swing.plaf.PanelUI;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class LangManager {
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+    private final YamlDocument langDocument;
+
+    public LangManager(YamlDocument langDocument) {
+        this.langDocument = langDocument;
+    }
+
+    public String getRaw(String key){
+        String raw = null;
+
+        if (langDocument.isList(key)){
+            List<String> strings = langDocument.getStringList(key);
+            raw = String.join("<br>", strings);
+        }
+
+        if (raw == null){
+            raw = langDocument.getString(key);
+        }
+
+        if (raw == null){
+            return key;
+        }
+
+        return raw;
+    }
+    public Component get(String key){
+        String raw = getRaw(key);
+        return miniMessage.deserialize(raw);
+    }
+
+    public Component get(String key, Replace... replaces){
+        String raw = getRaw(key);
+
+        for (Replace replace : replaces){
+            raw = replace.replace(raw);
+        }
+
+        return miniMessage.deserialize(raw);
+    }
+
+    public Component getRandom(String key){
+        List<String> list = langDocument.getStringList(key);
+
+        if (list == null){
+            return miniMessage.deserialize(key);
+        }
+
+        int randomInt = ThreadLocalRandom.current().nextInt(list.size());
+        String raw = list.get(randomInt);
+
+        return miniMessage.deserialize(raw);
+    }
+
+    public void send(String key, Player player, Replace... replaces){
+        Component message = get(key, replaces);
+        player.sendMessage(message);
+    }
+
+
+}
+;

src/main/java/xyz/soukup/ecocraftVelocity/configuration/Replace.java

@@ -0,0 +1,42 @@
+package xyz.soukup.ecocraftVelocity.configuration;
+
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+public class Replace {
+    private final String key;
+    private final String value;
+    private final Boolean allowFormatting;
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+
+    public Replace(String key, String value){
+        this.key = key;
+        this.value = value;
+        this.allowFormatting = false;
+    }
+
+    public  Replace(String key, String value, Boolean allowFormatting) {
+        this.key = key;
+        this.value = value;
+        this.allowFormatting = allowFormatting;
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public Boolean getAllowFormatting() {
+        return allowFormatting;
+    }
+
+    public String replace(String string){
+        if (allowFormatting){
+            return string.replace("<" + key + ">", value);
+        }else{
+            return string.replace("<" + key + ">", miniMessage.stripTags(value));
+        }
+    }
+}

src/main/java/xyz/soukup/ecocraftVelocity/motd/MotdRequestEvent.java

@@ -0,0 +1,43 @@
+package xyz.soukup.ecocraftVelocity.motd;
+
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.proxy.ProxyPingEvent;
+import com.velocitypowered.api.proxy.server.ServerPing;
+import com.velocitypowered.api.util.Favicon;
+import net.kyori.adventure.text.Component;
+import xyz.soukup.ecocraftVelocity.configuration.LangManager;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+public class MotdRequestEvent {
+    private final LangManager langManager;
+    private final Path dataDirectory;
+
+    public MotdRequestEvent(LangManager langManager, Path dataDirectory) {
+        this.langManager = langManager;
+        this.dataDirectory = dataDirectory;
+    }
+
+
+    @Subscribe
+    public void onServerPing(ProxyPingEvent event){
+
+        Component motd = langManager.get("motd.line1")
+                .append(Component.newline())
+                .append(langManager.getRandom("motd.quotes"));
+
+
+        ServerPing serverPing = event.getPing();
+        ServerPing.Builder builder = serverPing.asBuilder();
+        builder.description(motd);
+
+        try {
+            builder.favicon(Favicon.create(dataDirectory.resolve("server-icon.png")));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        event.setPing(builder.build());
+    }
+}

src/main/java/xyz/soukup/ecocraftVelocity/tab/GlobalTab.java

@@ -7,19 +7,18 @@ import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.player.TabListEntry;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
+import xyz.soukup.ecocraftVelocity.configuration.LangManager;
-import net.kyori.adventure.text.format.TextDecoration;
+import xyz.soukup.ecocraftVelocity.configuration.Replace;
-import net.kyori.adventure.text.minimessage.MiniMessage;
-import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 
 import java.util.UUID;
 
 public class GlobalTab {
     private final ProxyServer server;
-    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+    private final LangManager langManager;
 
-    public GlobalTab(ProxyServer server) {
+    public GlobalTab(ProxyServer server, LangManager langManager) {
         this.server = server;
+        this.langManager = langManager;
     }
 
     @Subscribe
@@ -28,7 +27,7 @@ public class GlobalTab {
         for (Player recipient : server.getAllPlayers()) {
             for (Player onlinePlayer : server.getAllPlayers()) {
 
-                Component displayName = formatPlayerName(onlinePlayer);
+                Component displayName = langManager.get("tab.name-format", new Replace("name", onlinePlayer.getUsername()));
 
                 if (!recipient.getTabList().containsEntry(onlinePlayer.getUniqueId())) {
                     TabListEntry entry = TabListEntry.builder()
@@ -62,18 +61,11 @@ public class GlobalTab {
     public void updateTablist() {
         int onlineCount = server.getPlayerCount();
 
-        String header = "<br><gold><bold>EcoCraft.cz" +
+        Component header = langManager.get("tab.header");
-                "<br><red><bold>   BETA SERVER   <br>";
+        Component footer = langManager.get("tab.footer");
-
-        String footer = "<yellow><br>   www.ecocraft.cz   <br>";
 
         for (Player player : server.getAllPlayers()) {
-            player.sendPlayerListHeaderAndFooter(miniMessage.deserialize(header), miniMessage.deserialize(footer));
+            player.sendPlayerListHeaderAndFooter(header, footer);
-        }
         }
-
-    private Component formatPlayerName(Player player) {
-        String format = "<white><bold><name>";
-        return miniMessage.deserialize(format, Placeholder.unparsed("name", player.getUsername()));
     }
 }

src/main/resources/messages.yml

@@ -0,0 +1,38 @@
+motd:
+  line1: "<bold><gold>Eco<yellow>Craft<white>.cz </bold><green>CZ/SK Ekonomický Server"
+  new-message: "<aqua><bold>Čeká na tebe nová zpráva!"
+  quotes:
+    - "<gray>„Kdo jinému jámu kopá, ten je u něj na brigádě“"
+    - "<gray>„Ta java to je hrozný jazyk“"
+    - "<gray>„Sníh padá jinak, když kráčí vůdce“"
+    - "<gray>„Kdo mi to tu krade obilí?“"
+    - "<gray>„Není ta hora až moc velká?“"
+    - "<gray>„I use arch linux btw“"
+    - "<gray>„co jste provedli XD“"
+    - "<gray>„Kdo tu staví ty hákáče?“"
+tab:
+  header:
+    - ""
+    - "<gold><bold>EcoCraft.cz"
+    - "<aqua><bold>   BETA SERVER   </bold>"
+    - ""
+  footer:
+    - ""
+    - "  <yellow>www.soukup.xyz"
+    - ""
+  name-format: "<white><bold><name>"
+chat-format:
+  join: "<gray>[<green>+<gray>] <name>"
+  leave: "<gray>[<red>-<gray>] <name>"
+  player-message: "<hover:show_text:'<yellow><bold><name><br><white>Klikni pro napsání hráči'><click:suggest_command:/msg <name>><yellow><bold><name></click></hover>: <white><msg>"
+  direct:
+    reply:
+      multiple-receivers:
+        prefix: "<gold><bold>Vyber příjemce:<reset><br>"
+        suffix: ""
+        separator: "<br>"
+        name-format: "<hover:show_text:'<green>Odeslat hráči <name>'><click:run_command:'/msg <name> <msg>'><white> <b>-> </b><name></click></hover>"
+      error:
+        no-recipients: "<red>Nemáš komu odepsat"
+    sender: "<hover:show_text:'<yellow><bold><name></bold><br><white>Klikni pro odepsání'><click:suggest_command:/msg <name>><blue>já <white><bold>▶ </bold><blue><name></click></hover><gray>: <white><msg>"
+    receiver: "<hover:show_text:'<yellow><bold><name></bold><br><white>Klikni pro odepsání'><click:suggest_command:/msg <name>><blue><name> <white><bold>▶ </bold><blue>já</click></hover><gray>: <white><msg>"