Remove Galaxy dependency

Switched back to paper since we don't use any features from Galaxy that aren't already in paper

Jenkinsfile

@@ -0,0 +1,20 @@
+pipeline {
+    agent any
+    stages {
+        stage('Gradle') {
+            steps {
+                sh './gradlew build'
+            }
+        }
+        stage('Archive') {
+            steps {
+                archiveArtifacts artifacts: 'build/libs/', followSymlinks: false
+            }
+        }
+        stage('discord') {
+            steps {
+                discordSend description: "Build: ${BUILD_NUMBER}", showChangeset: true, result: currentBuild.currentResult, title: currentBuild.fullProjectName, webhookURL: env.discordwebhook
+            }
+        }
+    }
+}

api/build.gradle.kts

@@ -3,9 +3,10 @@ plugins {
 }
 
 dependencies {
-    compileOnly("com.alttd:Galaxy-API:1.19.2-R0.1-SNAPSHOT") {
+//    compileOnly("com.alttd:Galaxy-API:1.21-R0.1-SNAPSHOT") {
 //        exclude("net.kyori")
-    }
+//    }
+    compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
     compileOnly("org.spongepowered:configurate-yaml:4.1.2") // Configurate
     compileOnly("net.luckperms:api:5.3") // Luckperms
 }

api/src/main/java/com/alttd/chat/config/Config.java

@@ -32,7 +32,7 @@ public final class Config {
 
     public static File CONFIGPATH;
     public static void init() {
-        CONFIGPATH = new File(System.getProperty("user.home") + File.separator + "share" + File.separator + "configs" + File.separator + "ChatPlugin");
+        CONFIGPATH = new File(File.separator + "mnt" + File.separator + "configs" + File.separator + "ChatPlugin");
         CONFIG_FILE = new File(CONFIGPATH, "config.yml");
         configLoader = YamlConfigurationLoader.builder()
                 .file(CONFIG_FILE)

api/src/main/java/com/alttd/chat/objects/chat_log/ChatLogHandler.java

@@ -28,8 +28,10 @@ public class ChatLogHandler {
     private final HashMap<UUID, List<ChatLog>> chatLogs = new HashMap<>();
 
     public ChatLogHandler(boolean enableLogging) {
-        if (!enableLogging)
+        if (!enableLogging) {
+            ALogger.info("Logging is not enabled on this server.");
             return;
+        }
         Duration deleteThreshold = Duration.ofDays(Config.CHAT_LOG_DELETE_OLDER_THAN_DAYS);
         ChatLogQueries.deleteOldMessages(deleteThreshold).thenAccept(success -> {
             if (success) {
@@ -39,8 +41,12 @@ public class ChatLogHandler {
             }
         });
         executorService = Executors.newSingleThreadScheduledExecutor();
-        executorService.scheduleAtFixedRate(() -> saveToDatabase(false),
+        executorService.scheduleAtFixedRate(() -> {
+                    saveToDatabase(false);
+                    ALogger.info(String.format("Running scheduler to save messages with a %d delay", Config.CHAT_LOG_SAVE_DELAY_MINUTES));
+                },
                 Config.CHAT_LOG_SAVE_DELAY_MINUTES, Config.CHAT_LOG_SAVE_DELAY_MINUTES, TimeUnit.MINUTES);
+        ALogger.info("Logging has started!");
     }
 
     /**
@@ -70,19 +76,27 @@ public class ChatLogHandler {
 
     private void saveToDatabase(boolean onMainThread) {
         savingToDatabase(true);
+        ALogger.info(String.format("Saving %d messages to database", chatLogs.size()));
         CompletableFuture<Boolean> booleanCompletableFuture = ChatLogQueries.storeMessages(chatLogs);
         if (onMainThread) {
             booleanCompletableFuture.join();
+            ALogger.info("Finished saving messages on main thread");
             return;
         }
         booleanCompletableFuture.whenComplete((result, throwable) -> {
             if (throwable == null && result) {
                 chatLogs.clear();
+            } else {
+                ALogger.error("Failed to save chat messages.");
             }
             savingToDatabase(false);
+            if (!chatLogQueue.isEmpty()) {
+                ALogger.info("Adding back messages from queue to chatLogs map");
+            }
             while (!chatLogQueue.isEmpty()) {
                 addLog(chatLogQueue.remove());
             }
+            ALogger.info("Finished saving messages");
         });
     }
 

build.gradle.kts

@@ -1,25 +1,12 @@
 plugins {
     `java-library`
-    id("com.github.johnrengelman.shadow") version "7.1.0"
+    id("io.github.goooler.shadow") version "8.1.8"
 }
 
 allprojects {
     group = "com.alttd.chat"
     version = "2.0.0-SNAPSHOT"
     description = "All in one minecraft chat plugin"
-
-//    repositories {
-//        mavenCentral()
-//        maven("https://repo.destro.xyz/snapshots") // Altitude - Galaxy
-//        maven("https://oss.sonatype.org/content/groups/public/") // Adventure
-//        maven("https://oss.sonatype.org/content/repositories/snapshots/") // Minimessage
-//        maven("https://oss.sonatype.org/content/repositories/") // Minimessage
-//        maven("https://nexus.velocitypowered.com/repository/") // Velocity
-//        maven("https://nexus.velocitypowered.com/repository/maven-public/") // Velocity
-//        maven("https://repo.spongepowered.org/maven") // Configurate
-//        maven("https://repo.extendedclip.com/content/repositories/placeholderapi/") // Papi
-//        maven("https://jitpack.io")
-//    }
 }
 
 subprojects {
@@ -27,7 +14,7 @@ subprojects {
 
     java {
         toolchain {
-            languageVersion.set(JavaLanguageVersion.of(17))
+            languageVersion.set(JavaLanguageVersion.of(21))
         }
     }
 

galaxy/build.gradle.kts

@@ -1,58 +1,25 @@
-import java.io.FileOutputStream
-import java.net.URL
-
 plugins {
     `maven-publish`
-    id("com.github.johnrengelman.shadow")
-    id("xyz.jpenilla.run-paper") version "1.0.6"
+    id("io.github.goooler.shadow")
 }
 
 dependencies {
     implementation(project(":api")) // API
-    compileOnly("com.alttd:Galaxy-API:1.20.4-R0.1-SNAPSHOT") // Galaxy
+//    compileOnly("com.alttd:Galaxy-API:1.21-R0.1-SNAPSHOT") // Galaxy
+    compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
     compileOnly("com.gitlab.ruany:LiteBansAPI:0.3.5") // move to proxy
     compileOnly("org.apache.commons:commons-lang3:3.12.0") // needs an alternative, already removed from upstream api and will be removed in server
     compileOnly("net.luckperms:api:5.3") // Luckperms
-    compileOnly(files("../libs/CMI.jar"))
 }
 
 tasks {
 
     shadowJar {
         archiveFileName.set("${rootProject.name}-${project.name}-${project.version}.jar")
-//        minimize()
     }
 
     build {
-//        setBuildDir("${rootProject.buildDir}")
         dependsOn(shadowJar)
     }
 
-    runServer {
-        val dir = File(System.getProperty("user.home") + "/share/devserver/");
-        if (!dir.parentFile.exists()) {
-            dir.parentFile.mkdirs()
-        }
-        runDirectory.set(dir)
-
-        val fileName = "/galaxy.jar"
-        var file = File(dir.path + fileName)
-
-        if (!file.parentFile.exists()) {
-            file.parentFile.mkdirs()
-        }
-        if (!file.exists()) {
-            download("https://repo.destro.xyz/snapshots/com/alttd/Galaxy-Server/Galaxy-paperclip-1.19.2-R0.1-SNAPSHOT-reobf.jar", file)
-        }
-        serverJar(file)
-        minecraftVersion("1.19.2")
-    }
-}
-
-fun download(link: String, path: File) {
-    URL(link).openStream().use { input ->
-        FileOutputStream(path).use { output ->
-            input.copyTo(output)
-        }
-    }
 }

galaxy/src/main/java/com/alttd/chat/ChatPlugin.java

@@ -38,9 +38,9 @@ public class ChatPlugin extends JavaPlugin {
         chatAPI = new ChatImplementation();
         chatHandler = new ChatHandler();
         DatabaseConnection.initialize();
-        serverConfig = new ServerConfig(Bukkit.getServerName());
+        serverConfig = new ServerConfig(Bukkit.getServer().getName());
         ChatLogHandler chatLogHandler = ChatLogHandler.getInstance(true);
-        registerListener(new PlayerListener(serverConfig), new ChatListener(chatLogHandler), new BookListener(), new ShutdownListener(chatLogHandler));
+        registerListener(new PlayerListener(serverConfig), new ChatListener(chatLogHandler), new BookListener(), new ShutdownListener(chatLogHandler, this));
         if(serverConfig.GLOBALCHAT) {
             registerCommand("globalchat", new GlobalChat());
             registerCommand("toggleglobalchat", new ToggleGlobalChat());
@@ -119,7 +119,7 @@ public class ChatPlugin extends JavaPlugin {
     public void ReloadConfig() {
         chatAPI.ReloadConfig();
         chatAPI.ReloadChatFilters();
-        serverConfig = new ServerConfig(Bukkit.getServerName());
+        serverConfig = new ServerConfig(Bukkit.getServer().getName());
         Bukkit.broadcast(Utility.parseMiniMessage("Reloaded ChatPlugin Config."), "command.chat.reloadchat");
         ALogger.info("Reloaded ChatPlugin config.");
     }

galaxy/src/main/java/com/alttd/chat/commands/ChatChannel.java

@@ -38,7 +38,7 @@ public class ChatChannel extends BukkitCommand {
         }
 
         if(args.length == 0 && player.hasPermission(channel.getPermission())) {
-            player.sendMiniMessage(Config.CUSTOM_CHANNEL_TOGGLED, TagResolver.resolver(
+            player.sendRichMessage(Config.CUSTOM_CHANNEL_TOGGLED, TagResolver.resolver(
                     Placeholder.unparsed("channel", channel.getChannelName()),
                     Placeholder.component("status", toggleableForCustomChannel.toggle(player.getUniqueId())
                             ? Config.TOGGLED_ON : Config.TOGGLED_OFF)));

galaxy/src/main/java/com/alttd/chat/commands/PartyChat.java

@@ -27,7 +27,7 @@ public class PartyChat extends Toggleable implements CommandExecutor {
         }
 
         if(args.length == 0) {
-            player.sendMiniMessage(Config.PARTY_TOGGLED, Placeholder.component("status",
+            player.sendRichMessage(Config.PARTY_TOGGLED, Placeholder.component("status",
                     toggle(player.getUniqueId()) ? Config.TOGGLED_ON : Config.TOGGLED_OFF));
             return true;
         }

galaxy/src/main/java/com/alttd/chat/handler/ChatHandler.java

@@ -26,6 +26,7 @@ import org.bukkit.inventory.ItemStack;
 
 import java.util.*;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
 
 public class ChatHandler {
 
@@ -130,7 +131,7 @@ public class ChatHandler {
                 Placeholder.component("sender", senderName),
                 Placeholder.component("prefix", prefix),
                 Placeholder.component("message", parseMessageContent(player, message)),
-                Placeholder.parsed("server", Bukkit.getServerName())
+                Placeholder.parsed("server", Bukkit.getServer().getName())
         );
 
         Component component = Utility.parseMiniMessage(Config.GCFORMAT, placeholders);
@@ -164,7 +165,7 @@ public class ChatHandler {
         TagResolver placeholders = TagResolver.resolver(
                 Placeholder.component("sender", senderName),
                 Placeholder.component("message", parseMessageContent(player, message)),
-                Placeholder.parsed("server", Bukkit.getServerName()),
+                Placeholder.parsed("server", Bukkit.getServer().getName()),
                 Placeholder.parsed("channel", channel.getChannelName())
         );
         Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders);
@@ -237,12 +238,21 @@ public class ChatHandler {
     }
 
     private void sendChatChannelMessage(CustomChannel chatChannel, UUID uuid, Component component) {
-        if (!chatChannel.getServers().contains(Bukkit.getServerName())) return;
+        if (!chatChannel.getServers().contains(Bukkit.getServer().getName())) {
+            return;
+        }
 
-        Bukkit.getServer().getOnlinePlayers().stream()
-                .filter(p -> p.hasPermission(chatChannel.getPermission()))
-                .filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers().contains(uuid))
-                .forEach(p -> p.sendMessage(component));
+        Player player = Bukkit.getPlayer(uuid);
+        if (player == null) {
+            return;
+        }
+
+        Stream<? extends Player> stream = Bukkit.getServer().getOnlinePlayers().stream()
+                .filter(p -> p.hasPermission(chatChannel.getPermission()));
+        if (!player.hasPermission("chat.ignorebypass")) {
+            stream = stream.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers().contains(uuid) && !p.hasPermission("chat.ignorebypass"));
+        }
+        stream.forEach(p -> p.sendMessage(component));
     }
 
     private void sendPluginMessage(Player player, String channel, Component component) {

galaxy/src/main/java/com/alttd/chat/listeners/ChatListener.java

@@ -32,8 +32,10 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.HashSet;
 import java.util.Set;
+import java.util.UUID;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class ChatListener implements Listener {
 
@@ -81,18 +83,14 @@ public class ChatListener implements Listener {
         }
 
         Player player = event.getPlayer();
-
-        Set<Player> receivers = event.viewers().stream().filter(audience -> audience instanceof Player)
-                .map(audience -> (Player) audience)
-                .filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId()))
-                .collect(Collectors.toSet());
+        UUID uuid = player.getUniqueId();
 
         Component input = event.message().colorIfAbsent(NamedTextColor.WHITE);
 
         ModifiableString modifiableString = new ModifiableString(input);
 
          // todo a better way for this
-        if(!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, true, "chat", filterType -> {
+        if(!RegexManager.filterText(player.getName(), uuid, modifiableString, true, "chat", filterType -> {
             if (!filterType.equals(FilterType.PUNISH)) {
                 ALogger.warn("Received another FilterType than punish when filtering chat and executing a filter action");
                 return;
@@ -100,7 +98,7 @@ public class ChatListener implements Listener {
             ByteArrayDataOutput out = ByteStreams.newDataOutput();
             out.writeUTF("punish");
             out.writeUTF(player.getName());
-            out.writeUTF(player.getUniqueId().toString());
+            out.writeUTF(uuid.toString());
             out.writeUTF(modifiableString.string());
             player.sendPluginMessage(ChatPlugin.getInstance(), Config.MESSAGECHANNEL, out.toByteArray());
         })) {
@@ -108,10 +106,19 @@ public class ChatListener implements Listener {
             GalaxyUtility.sendBlockedNotification("Language", player,
                     modifiableString.component(),
                     "");
-            chatLogHandler.addChatLog(player.getUniqueId(), player.getServer().getServerName(), PlainTextComponentSerializer.plainText().serialize(input), true);
+            chatLogHandler.addChatLog(uuid, player.getServer().getName(), PlainTextComponentSerializer.plainText().serialize(input), true);
             return; // the message was blocked
         }
 
+        Stream<Player> stream = event.viewers().stream().filter(audience -> audience instanceof Player)
+                .map(audience -> (Player) audience);
+
+        if (!player.hasPermission("chat.ignorebypass")) {
+            stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid)
+                                               && !receiver.hasPermission("chat.ignorebypass"));
+        }
+        Set<Player> receivers = stream.collect(Collectors.toSet());
+
         Set<Player> playersToPing = new HashSet<>();
         pingPlayers(playersToPing, modifiableString, player);
 
@@ -122,7 +129,7 @@ public class ChatListener implements Listener {
         for (Player pingPlayer : playersToPing) {
             pingPlayer.playSound(pingPlayer.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1);
         }
-        chatLogHandler.addChatLog(player.getUniqueId(), player.getServer().getServerName(), modifiableString.string(), false);
+        chatLogHandler.addChatLog(uuid, player.getServer().getName(), modifiableString.string(), false);
         ALogger.info(PlainTextComponentSerializer.plainText().serialize(input));
     }
 
@@ -136,11 +143,12 @@ public class ChatListener implements Listener {
             Pattern nickPattern = Pattern.compile("\\b(?<!\\\\)" + nickName + "\\b", Pattern.CASE_INSENSITIVE);
 //            Pattern escapedNickPattern = Pattern.compile("\\b\\\\" + nickName + "\\b", Pattern.CASE_INSENSITIVE);
 
+            ChatUser onlinePlayerUser = ChatUserManager.getChatUser(onlinePlayer.getUniqueId());
             if (namePattern.matcher(modifiableString.string()).find()) {
                 modifiableString.replace(TextReplacementConfig.builder()
                         .once()
                         .match(namePattern)
-                        .replacement(mention.append(onlinePlayer.displayName()))
+                        .replacement(mention.append(onlinePlayerUser.getDisplayName()))
                         .build());
                 //TODO replace all instances of \name with just name but using the match result so the capitalization doesn't change
 //                modifiableString.replace(TextReplacementConfig.builder()
@@ -150,15 +158,17 @@ public class ChatListener implements Listener {
 //                            String substring = a.group().substring(1);
 //                            return ;
 //                        });
-                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId()))
+                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
+                    && !player.hasPermission("chat.ignorebypass"))
                     playersToPing.add(onlinePlayer);
             } else if (nickPattern.matcher(modifiableString.string()).find()) {
                 modifiableString.replace(TextReplacementConfig.builder()
                         .once()
                         .match(nickPattern)
-                        .replacement(mention.append(onlinePlayer.displayName()))
+                        .replacement(mention.append(onlinePlayerUser.getDisplayName()))
                         .build());
-                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId()))
+                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
+                    && !player.hasPermission("chat.ignorebypass"))
                     playersToPing.add(onlinePlayer);
             }
         }

galaxy/src/main/java/com/alttd/chat/listeners/PlayerListener.java

@@ -11,11 +11,13 @@ import com.alttd.chat.objects.Toggleable;
 import com.alttd.chat.util.GalaxyUtility;
 import com.alttd.chat.util.Utility;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextReplacementConfig;
 import net.kyori.adventure.text.format.Style;
 import net.kyori.adventure.text.format.TextColor;
 import net.kyori.adventure.text.format.TextDecoration;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -48,8 +50,8 @@ public class PlayerListener implements Listener {
         UUID uuid = player.getUniqueId();
         Toggleable.disableToggles(uuid);
 
-        if (serverConfig.FIRST_JOIN_MESSAGES && System.currentTimeMillis() - player.getFirstPlayed() < TimeUnit.SECONDS.toMillis(10)) {
-            player.getServer().sendMessage(MiniMessage.miniMessage().deserialize(Config.FIRST_JOIN, Placeholder.parsed("player", player.getName())));
+        if (serverConfig.FIRST_JOIN_MESSAGES && (!player.hasPlayedBefore() || System.currentTimeMillis() - player.getFirstPlayed() < TimeUnit.SECONDS.toMillis(10))) {
+            Bukkit.broadcast(MiniMessage.miniMessage().deserialize(Config.FIRST_JOIN, Placeholder.parsed("player", player.getName())));
         }
 
         ChatUser user = ChatUserManager.getChatUser(uuid);
@@ -103,22 +105,36 @@ public class PlayerListener implements Listener {
         Stack<Instant> playerDeathsStack = sendPlayerDeaths.computeIfAbsent(uuid, key -> new Stack<>());
         Instant cutOff = Instant.now().minus(Config.DEATH_MESSAGES_LIMIT_PERIOD_MINUTES, ChronoUnit.MINUTES);
 
-        while (playerDeathsStack.peek().isBefore(cutOff)) {
+        while (!playerDeathsStack.isEmpty() && playerDeathsStack.peek().isBefore(cutOff)) {
             playerDeathsStack.pop();
         }
 
         if (playerDeathsStack.size() > Config.DEATH_MESSAGES_MAX_PER_PERIOD || serverConfig.MUTED) {
             event.deathMessage(Component.empty());
             return;
-        } else {
+        }
             Component component = event.deathMessage();
-            if (component != null) {
-                component = Component.text("* ").append(component);
-                component = component.style(Style.style(TextColor.color(82, 80, 77), TextDecoration.ITALIC));
-                event.deathMessage(component);
-            }
-        }
+
         playerDeathsStack.push(Instant.now());
+        if (component == null) {
+            return;
+        }
+        TextReplacementConfig playerReplacement = TextReplacementConfig.builder()
+                .match(event.getPlayer().getName())
+                .replacement(event.getPlayer().displayName())
+                .build();
+        component = component.replaceText(playerReplacement);
+        Player killer = event.getPlayer().getKiller();
+        if (killer != null) {
+            TextReplacementConfig killerReplacement = TextReplacementConfig.builder()
+                    .match(killer.getName())
+                    .replacement(killer.displayName())
+                    .build();
+            component = component.replaceText(killerReplacement);
+        }
+        component = MiniMessage.miniMessage().deserialize("<dark_red>[</dark_red><red>☠</red><dark_red>]</dark_red> ").append(component);
+        component = component.style(Style.style(TextColor.color(255, 155, 48), TextDecoration.ITALIC));
+        event.deathMessage(component);
     }
 
 }

galaxy/src/main/java/com/alttd/chat/listeners/PluginMessage.java

@@ -15,20 +15,20 @@ import com.alttd.chat.util.Utility;
 import com.google.common.io.ByteArrayDataInput;
 import com.google.common.io.ByteStreams;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
 import org.bukkit.Bukkit;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.messaging.PluginMessageListener;
 import org.bukkit.scheduler.BukkitRunnable;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.UUID;
 
 public class PluginMessage implements PluginMessageListener {
 
     @Override
-    public void onPluginMessageReceived(String channel, Player player, byte[] bytes) {
+    public void onPluginMessageReceived(String channel, @NotNull Player ignored, byte[] bytes) {
         if (!channel.equals(Config.MESSAGECHANNEL)) {
             return;
         }
@@ -38,36 +38,37 @@ public class PluginMessage implements PluginMessageListener {
             case "privatemessagein": {
                 UUID uuid = UUID.fromString(in.readUTF());
                 String target = in.readUTF();
-                Player p = Bukkit.getPlayer(uuid);
+                Player player = Bukkit.getPlayer(uuid);
                 String message = in.readUTF();
                 UUID targetuuid = UUID.fromString(in.readUTF());
-                if (p != null) {
+                if (player == null) {
+                    break;
+                }
                 ChatUser chatUser = ChatUserManager.getChatUser(uuid);
-                    if (!chatUser.getIgnoredPlayers().contains(targetuuid)) {
-                        p.sendMessage(GsonComponentSerializer.gson().deserialize(message));
-                        p.playSound(p.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1); // todo load this from config
+                if (isTargetNotIgnored(chatUser, targetuuid)) {
+                    player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
+                    player.playSound(player.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1); // todo load this from config
                     ChatUser user = ChatUserManager.getChatUser(uuid);
                     if (!user.getReplyContinueTarget().equalsIgnoreCase(target))
                         user.setReplyTarget(target);
                 }
             }
-                break;
-            }
             case "privatemessageout": {
                 UUID uuid = UUID.fromString(in.readUTF());
                 String target = in.readUTF();
-                Player p = Bukkit.getPlayer(uuid);
+                Player player = Bukkit.getPlayer(uuid);
                 String message = in.readUTF();
                 UUID targetuuid = UUID.fromString(in.readUTF());
-                if (p != null) {
+                if (player == null) {
+                    break;
+                }
                 ChatUser chatUser = ChatUserManager.getChatUser(uuid);
-                    if (!chatUser.getIgnoredPlayers().contains(targetuuid)) {
+                if (isTargetNotIgnored(chatUser, targetuuid)) {
                     chatUser.setReplyTarget(target);
-                        p.sendMessage(GsonComponentSerializer.gson().deserialize(message));
+                    player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
 //                        ChatUser user = ChatUserManager.getChatUser(uuid);
 //                        user.setReplyTarget(target);
                 }
-                }
                 break;
             }
             case "globalchat": {
@@ -78,7 +79,7 @@ public class PluginMessage implements PluginMessageListener {
 
                 Bukkit.getOnlinePlayers().stream().filter(p -> p.hasPermission(Config.GCPERMISSION)).forEach(p -> {
                     ChatUser chatUser = ChatUserManager.getChatUser(p.getUniqueId());
-                    if (!chatUser.getIgnoredPlayers().contains(uuid)) {
+                    if (isTargetNotIgnored(chatUser, uuid)) {
                         p.sendMessage(GsonComponentSerializer.gson().deserialize(message));
                     }
                 });
@@ -193,7 +194,7 @@ public class PluginMessage implements PluginMessageListener {
             ALogger.warn("Received ChatChannel message for non existent channel.");
             return;
         }
-        if (!chatChannel.getServers().contains(Bukkit.getServerName())) {
+        if (!chatChannel.getServers().contains(Bukkit.getServer().getName())) {
             ALogger.warn("Received ChatChannel message for the wrong server.");
             return;
         }
@@ -216,4 +217,15 @@ public class PluginMessage implements PluginMessageListener {
         }.runTaskAsynchronously(ChatPlugin.getInstance());
     }
 
+    private boolean isTargetNotIgnored(ChatUser chatUser, UUID targetUUID) {
+        if (!chatUser.getIgnoredPlayers().contains(targetUUID)) {
+            return true;
+        }
+        Player target = Bukkit.getPlayer(targetUUID);
+        if (target == null) {
+            return true;
+        }
+        return target.hasPermission("chat.ignorebypass");
+    }
+
 }

galaxy/src/main/java/com/alttd/chat/listeners/ShutdownListener.java

@@ -4,17 +4,23 @@ import com.alttd.chat.objects.chat_log.ChatLogHandler;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.plugin.Plugin;
 
 public class ShutdownListener implements Listener {
 
     private final ChatLogHandler chatLogHandler;
+    private final Plugin thisPlugin;
 
-    public ShutdownListener(ChatLogHandler chatLogHandler) {
+    public ShutdownListener(ChatLogHandler chatLogHandler, Plugin thisPlugin) {
         this.chatLogHandler = chatLogHandler;
+        this.thisPlugin = thisPlugin;
     }
 
     @EventHandler
     public void onShutdown(PluginDisableEvent event) {
+        if (!event.getPlugin().getName().equals(thisPlugin.getName())){
+            return;
+        }
         chatLogHandler.shutDown();
     }
 

galaxy/src/main/java/com/alttd/chat/nicknames/NickUtilities.java

@@ -149,24 +149,24 @@ public class NickUtilities
 
     public static boolean validNick(Player sender, OfflinePlayer target, String nickName) {
         if (!noBlockedCodes(nickName)) {
-            sender.sendMiniMessage(Config.NICK_BLOCKED_COLOR_CODES, null);
+            sender.sendRichMessage(Config.NICK_BLOCKED_COLOR_CODES);
             return false;
         }
 
         if (!Utility.checkNickBrightEnough(nickName)) {
-            sender.sendMiniMessage("<red>At least one color must be brighter than 30 for each color</red>", null);
+            sender.sendRichMessage("<red>At least one color must be brighter than 30 for each color</red>");
             return false;
         }
 
         String cleanNick = NickUtilities.removeAllColors(nickName);
 
         if (cleanNick.length() < 3 || cleanNick.length() > 16) {
-            sender.sendMiniMessage(Config.NICK_INVALID_LENGTH, null);
+            sender.sendRichMessage(Config.NICK_INVALID_LENGTH);
             return false;
         }
 
         if (!cleanNick.matches("[a-zA-Z0-9_]*") || nickName.length() > 192) { //192 is if someone puts {#xxxxxx<>} in front of every letter
-            sender.sendMiniMessage(Config.NICK_INVALID_CHARACTERS, null);
+            sender.sendRichMessage(Config.NICK_INVALID_CHARACTERS);
             return false;
         }
 
@@ -183,7 +183,7 @@ public class NickUtilities
                 if (uniqueId.equals(uuid)){
                     ChatPlugin.getInstance().getLogger().info(uuid + " " + uniqueId);
                 }
-                sender.sendMiniMessage(Config.NICK_TAKEN, null);
+                sender.sendRichMessage(Config.NICK_TAKEN);
                 return false;
             }
         }

galaxy/src/main/java/com/alttd/chat/nicknames/Nicknames.java

@@ -1,7 +1,5 @@
 package com.alttd.chat.nicknames;
 
-import com.Zrips.CMI.CMI;
-import com.Zrips.CMI.Containers.CMIUser;
 import com.alttd.chat.ChatAPI;
 import com.alttd.chat.ChatPlugin;
 import com.alttd.chat.config.Config;
@@ -13,7 +11,6 @@ import com.alttd.chat.objects.Nick;
 import com.alttd.chat.util.Utility;
 import com.google.common.io.ByteArrayDataOutput;
 import com.google.common.io.ByteStreams;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.luckperms.api.LuckPerms;
@@ -114,7 +111,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
                                 Placeholder.component("nickname", chatUser.getDisplayName()),
                                 Placeholder.parsed("currentnickname", chatUser.getNickNameString())
                         );
-                        player.sendMiniMessage(Config.NICK_CURRENT, placeholders);
+                        player.sendRichMessage(Config.NICK_CURRENT, placeholders);
                     }
                     break;
                 case "help":
@@ -384,7 +381,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
         ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
         user.setDisplayName(player.getName());
         player.displayName(user.getDisplayName());
-        updateCMIUser(player, null);
+//        updateCMIUser(player, null);
     }
 
     public String getNick(final Player player) {
@@ -399,25 +396,25 @@ public class Nicknames implements CommandExecutor, TabCompleter {
         ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
         user.setDisplayName(nickName);
         player.displayName(user.getDisplayName());
-        updateCMIUser(player, nickName);
+//        updateCMIUser(player, nickName);
     }
 
 //    public static String format(final String m) {
 //        return NickUtilities.applyColor(m);
 //    }
 
-    public void updateCMIUser(Player player, String nickName) {
-        if (!isCMIEnabled())
-            return;
-
-        CMIUser cmiUser = CMI.getInstance().getPlayerManager().getUser(player);
-        if (nickName == null){
-            cmiUser.setNickName(null, true);
-        } else {
-            cmiUser.setNickName(NickUtilities.applyColor(nickName), true);
-        }
-        cmiUser.updateDisplayName();
-    }
+//    public void updateCMIUser(Player player, String nickName) {
+//        if (!isCMIEnabled())
+//            return;
+//
+//        CMIUser cmiUser = CMI.getInstance().getPlayerManager().getUser(player);
+//        if (nickName == null){
+//            cmiUser.setNickName(null, true);
+//        } else {
+//            cmiUser.setNickName(NickUtilities.applyColor(nickName), true);
+//        }
+//        cmiUser.updateDisplayName();
+//    }
 
     private Boolean isCMIEnabled = null;
     private Boolean isCMIEnabled() {

galaxy/src/main/java/com/alttd/chat/nicknames/NicknamesEvents.java

@@ -1,12 +1,8 @@
 package com.alttd.chat.nicknames;
 
-import com.Zrips.CMI.commands.list.colorlimits;
-import com.Zrips.CMI.utils.Util;
 import com.alttd.chat.ChatPlugin;
 import com.alttd.chat.config.Config;
 import com.alttd.chat.database.Queries;
-import com.alttd.chat.managers.ChatUserManager;
-import com.alttd.chat.objects.ChatUser;
 import com.alttd.chat.objects.Nick;
 import com.alttd.chat.util.ALogger;
 import com.google.common.io.ByteArrayDataInput;

galaxy/src/main/java/com/alttd/chat/util/ToggleableForCustomChannel.java

@@ -41,6 +41,7 @@ public class ToggleableForCustomChannel extends Toggleable {
         new BukkitRunnable() {
             @Override
             public void run() {
+                ALogger.info(String.format("%s sent %s message: %s", player.getName(), customChannel.getChannelName(), message));
                 ChatPlugin.getInstance().getChatHandler().chatChannel(player, customChannel, message);
             }
         }.runTaskAsynchronously(ChatPlugin.getInstance());

settings.gradle.kts

@@ -4,11 +4,14 @@ include(":api")
 include(":galaxy")
 include(":velocity")
 
+val nexusUser = providers.gradleProperty("alttdSnapshotUsername").get()
+val nexusPass = providers.gradleProperty("alttdSnapshotPassword").get()
+
 dependencyResolutionManagement {
     repositories {
 //        mavenLocal()
         mavenCentral()
-        maven("https://repo.destro.xyz/snapshots") // Altitude - Galaxy
+//        maven("https://repo.destro.xyz/snapshots") // Altitude - Galaxy
         maven("https://oss.sonatype.org/content/groups/public/") // Adventure
         maven("https://oss.sonatype.org/content/repositories/snapshots/") // Minimessage
         maven("https://nexus.velocitypowered.com/repository/") // Velocity
@@ -16,6 +19,14 @@ dependencyResolutionManagement {
         maven("https://repo.spongepowered.org/maven") // Configurate
         maven("https://repo.extendedclip.com/content/repositories/placeholderapi/") // Papi
         maven("https://jitpack.io")
+        maven {
+            name = "nexus"
+            url = uri("https://repo.alttd.com/repository/alttd-snapshot/")
+            credentials {
+                username = nexusUser
+                password = nexusPass
+            }
+        }
     }
     repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
 }

velocity/build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
     `maven-publish`
-    id("com.github.johnrengelman.shadow")
+    id("io.github.goooler.shadow")
 }
 
 dependencies {
@@ -11,7 +11,7 @@ dependencies {
     implementation("org.spongepowered", "configurate-yaml", "4.1.2")
     compileOnly("net.kyori:adventure-text-minimessage:4.10.1")
     compileOnly("com.gitlab.ruany:LiteBansAPI:0.3.5")
-    compileOnly("com.alttd.proxydiscordlink:ProxyDiscordLink:1.0.0-BETA-SNAPSHOT")
+    compileOnly("com.alttd.proxydiscordlink:ProxyDiscordLink:1.0.1-SNAPSHOT")
 }
 
 tasks {

velocity/src/main/java/com/alttd/velocitychat/commands/VoteToMute.java

@@ -110,10 +110,10 @@ public class VoteToMute {
                             }
                             boolean countLowerRanks = false;
                             long count = getTotalEligiblePlayers(server, false);
-                            if (count < 10) {
+                            if (count < 6) {
                                 countLowerRanks = true;
                                 count = getTotalEligiblePlayers(server, true);
-                                if (count < 10) {
+                                if (count < 6) {
                                     commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Not enough eligible players online to vote.</red>"));
                                     return 1;
                                 }

velocity/src/main/java/com/alttd/velocitychat/commands/VoteToMuteHelper.java

@@ -16,6 +16,7 @@ import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.ServerConnection;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
+import jdk.jshell.execution.Util;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 
@@ -29,6 +30,8 @@ import java.util.stream.IntStream;
 
 public class VoteToMuteHelper {
 
+    private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>");
+
     public VoteToMuteHelper(ProxyServer proxyServer) {
         RequiredArgumentBuilder<CommandSource, String> playerNode = RequiredArgumentBuilder
                 .<CommandSource, String>argument("player", StringArgumentType.string())
@@ -116,7 +119,7 @@ public class VoteToMuteHelper {
                     return 1;
                 });
 
-        LiteralArgumentBuilder<CommandSource> enterPageNode = LiteralArgumentBuilder
+        LiteralArgumentBuilder<CommandSource> enterMessagesNode = LiteralArgumentBuilder
                 .<CommandSource>literal("messages")
                 .requires(commandSource -> commandSource.hasPermission("chat.vote-to-mute"))
                 .then(RequiredArgumentBuilder.<CommandSource, String>argument("list of messages", StringArgumentType.greedyString())
@@ -147,7 +150,7 @@ public class VoteToMuteHelper {
                             }
                             int highestLogEntry = max.get();
 
-                            if (voteToMuteStarter.getTotalLogEntries() > highestLogEntry) {
+                            if (voteToMuteStarter.getTotalLogEntries() < highestLogEntry) {
                                 commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Some of your selected messages do not exist.</red>"));
                                 return 1;
                             }
@@ -162,7 +165,7 @@ public class VoteToMuteHelper {
                             RegisteredServer server = currentServer.get().getServer();
                             long count = getTotalEligiblePlayers(server, voteToMuteStarter.countLowerRanks());
                             new ActiveVoteToMute(voteToMuteStarter.getVotedPlayer(), server, proxyServer, Duration.ofMinutes(5),
-                                    (int) count, voteToMuteStarter.countLowerRanks(), chatLogs)
+                                    (int) count, voteToMuteStarter.countLowerRanks(), chatLogs, player)
                                     .start();
                             return 1;
                         })
@@ -176,11 +179,11 @@ public class VoteToMuteHelper {
                 .then(playerNode
                         .then(yesNoNode
                                 .executes(commandContext -> {
-                                    if (!(commandContext.getSource() instanceof Player)) {
+                                    if (!(commandContext.getSource() instanceof Player player)) {
                                         commandContext.getSource().sendMessage(Utility.parseMiniMessage(
                                                 "<red>Only players are allowed to vote</red>"));
+                                        return 1;
                                     }
-                                    Player source = (Player) commandContext.getSource();
                                     String playerName = commandContext.getArgument("player", String.class);
                                     Optional<ActiveVoteToMute> optionalActiveVoteToMute = ActiveVoteToMute.getInstance(playerName);
                                     if (optionalActiveVoteToMute.isEmpty()) {
@@ -191,16 +194,25 @@ public class VoteToMuteHelper {
                                     ActiveVoteToMute activeVoteToMute = optionalActiveVoteToMute.get();
 
                                     if (!activeVoteToMute.countLowerRanks()) {
-                                        if (!source.hasPermission("chat.vote-to-mute")) {
-                                            source.sendMessage(Utility.parseMiniMessage("<red>You are not eligible to vote.</red>"));
+                                        if (!player.hasPermission("chat.vote-to-mute")) {
+                                            player.sendMessage(Utility.parseMiniMessage("<red>You are not eligible to vote.</red>"));
                                             return 1;
                                         }
                                     }
 
-                                    String vote = commandContext.getArgument("yesno", String.class);
+                                    String vote = commandContext.getArgument("yesNo", String.class);
                                     switch (vote.toLowerCase()) {
-                                        case "yes" -> activeVoteToMute.vote(source.getUniqueId(), true);
-                                        case "no" -> activeVoteToMute.vote(source.getUniqueId(), false);
+                                        case "yes" -> {
+                                            activeVoteToMute.vote(player.getUniqueId(), true);
+                                            commandContext.getSource().sendMessage(Utility.parseMiniMessage(
+                                                    "<green>You voted to mute. Thanks for voting, staff will be online soon to review!</green>"));
+                                            player.getCurrentServer().ifPresent(serverConnection -> notifyEligiblePlayers(serverConnection.getServer(), activeVoteToMute));
+                                        }
+                                        case "no" -> {
+                                            activeVoteToMute.vote(player.getUniqueId(), false);
+                                            commandContext.getSource().sendMessage(Utility.parseMiniMessage(
+                                                    "<green>You voted <red>not</red> to mute. Thanks for voting, staff will be online soon to review!</green>"));
+                                        }
                                         default -> commandContext.getSource().sendMessage(Utility.parseMiniMessage(
                                                 "<red><vote> is not a valid vote option</red>", Placeholder.parsed("vote", vote)));
                                     }
@@ -219,7 +231,7 @@ public class VoteToMuteHelper {
                 .requires(commandSource -> commandSource instanceof Player)
                 .then(voteNode)
                 .then(pageNode)
-                .then(enterPageNode)
+                .then(enterMessagesNode)
                 .executes(context -> {
                     sendHelpMessage(context.getSource());
                     return 1;
@@ -241,6 +253,18 @@ public class VoteToMuteHelper {
                 .count();
     }
 
+    private void notifyEligiblePlayers(RegisteredServer server, ActiveVoteToMute activeVoteToMute) {
+        Component message = Utility.parseMiniMessage("<prefix><green><voted_for> out of <total_votes> players have voted to mute <player></green>",
+                Placeholder.component("prefix", prefix),
+                Placeholder.parsed("voted_for", String.valueOf(activeVoteToMute.getVotedFor())),
+                Placeholder.parsed("total_votes", String.valueOf(activeVoteToMute.getTotalEligibleVoters())),
+                Placeholder.parsed("player", activeVoteToMute.getVotedPlayer().getUsername()));
+        boolean countLowerRanks = activeVoteToMute.countLowerRanks();
+        server.getPlayersConnected().stream()
+                .filter(player ->  countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
+                .forEach(player -> player.sendMessage(message));
+    }
+
     private void sendHelpMessage(CommandSource commandSource) {
         commandSource.sendMessage(Utility.parseMiniMessage("<red>Use: <gold>/votetomutehelper <player></gold>.</red>"));
     }

velocity/src/main/java/com/alttd/velocitychat/commands/vote_to_mute/ActiveVoteToMute.java

@@ -17,7 +17,6 @@ import org.jetbrains.annotations.NotNull;
 import java.awt.*;
 import java.time.Duration;
 import java.util.*;
-import java.util.List;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
@@ -29,6 +28,7 @@ public class ActiveVoteToMute {
     private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>");
 
     private final Player votedPlayer;
+    private final Player startedByPlayer;
     private HashSet<UUID> votedFor = new HashSet<>();
     private HashSet<UUID> votedAgainst = new HashSet<>();
     private int totalEligibleVoters;
@@ -36,6 +36,7 @@ public class ActiveVoteToMute {
     private final RegisteredServer server;
     private final ProxyServer proxyServer;
     private final Component chatLogs;
+    private boolean endedVote = false;
 
     public static Optional<ActiveVoteToMute> getInstance(String username) {
         if (!instances.containsKey(username))
@@ -74,7 +75,7 @@ public class ActiveVoteToMute {
     }
 
     public ActiveVoteToMute(@NotNull Player votedPlayer, @NotNull RegisteredServer server, ProxyServer proxyServer, Duration duration,
-                            int totalEligibleVoters, boolean countLowerRanks, Component chatLogs) {
+                            int totalEligibleVoters, boolean countLowerRanks, Component chatLogs, @NotNull Player startedByPlayer) {
         this.chatLogs = chatLogs;
         this.votedPlayer = votedPlayer;
         this.totalEligibleVoters = totalEligibleVoters;
@@ -85,6 +86,7 @@ public class ActiveVoteToMute {
         ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
         executorService.schedule(this::endVote,
                 duration.toMinutes(), TimeUnit.MINUTES);
+        this.startedByPlayer = startedByPlayer;
     }
 
     private RegisteredServer getServer() {
@@ -92,12 +94,14 @@ public class ActiveVoteToMute {
     }
 
     private void endVote() {
+        if (endedVote)
+            return;
         instances.remove(votedPlayer.getUsername());
         if (votePassed()) {
             mutePlayer();
             return;
         }
-        Component message = Utility.parseMiniMessage("<prefix> <red>The vote to mute <player> has failed, they will not be muted.</green>",
+        Component message = Utility.parseMiniMessage("<prefix> <red>The vote to mute <player> has failed, they will not be muted.</red>",
                 Placeholder.component("prefix", prefix), Placeholder.parsed("player", votedPlayer.getUsername()));
         server.getPlayersConnected().stream()
                 .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
@@ -118,6 +122,7 @@ public class ActiveVoteToMute {
             if (!votePassed()) {
                 return;
             }
+            endedVote = true;
             instances.remove(votedPlayer.getUsername());
             mutePlayer();
         } else {
@@ -128,6 +133,9 @@ public class ActiveVoteToMute {
 
     public boolean votePassed() {
         double totalVotes = (votedFor.size() + votedAgainst.size());
+        if (totalVotes == 0 || votedFor.isEmpty()) {
+            return false;
+        }
         if (totalVotes / totalEligibleVoters < 0.6) {
             return false;
         }
@@ -145,7 +153,7 @@ public class ActiveVoteToMute {
                 .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
                 .forEach(player -> player.sendMessage(message));
         proxyServer.getCommandManager().executeAsync(proxyServer.getConsoleCommandSource(),
-                String.format("tempmute %s 1h Muted by the community - under review.", votedPlayer.getUsername()));
+                String.format("tempmute %s 1h Muted by the community - under review. -p", votedPlayer.getUsername()));
 
 
         String chatLogsString = PlainTextComponentSerializer.plainText().serialize(chatLogs);
@@ -173,7 +181,10 @@ public class ActiveVoteToMute {
                 false);
         embedBuilder.addField("Server",
                 server.getServerInfo().getName().substring(0, 1).toUpperCase() + server.getServerInfo().getName().substring(1),
-                false);
+                true);
+        embedBuilder.addField("Started by",
+                String.format("Username: %s\nUUID: %s", startedByPlayer.getUsername(), startedByPlayer.getUniqueId().toString()),
+                true);
         return embedBuilder;
     }
 
@@ -204,7 +215,7 @@ public class ActiveVoteToMute {
     private Component getVoteStartMessage() {
         return Utility.parseMiniMessage(
                 String.format("""
-                        <prefix> <gold>[VoteMute]</gold> <green>A vote to mute <player> for one hour has been started, please read the logs below before voting.</green>
+                        <prefix> <green>A vote to mute <player> for one hour has been started, please read the logs below before voting.</green>
                         <logs>
                         <prefix> Click: <click:run_command:'/votetomutehelper vote %s yes'><red>Mute</red></click> --- <click:run_command:'/votetomutehelper vote %s no'><yellow>Don't mute</yellow></click>""",
                         votedPlayer.getUsername(), votedPlayer.getUsername()),
@@ -212,4 +223,16 @@ public class ActiveVoteToMute {
                 Placeholder.parsed("player", votedPlayer.getUsername()),
                 Placeholder.component("logs", chatLogs));
     }
+
+    public Player getVotedPlayer() {
+        return votedPlayer;
+    }
+
+    public int getVotedFor() {
+        return votedFor.size();
+    }
+
+    public int getTotalEligibleVoters() {
+        return totalEligibleVoters;
+    }
 }

velocity/src/main/java/com/alttd/velocitychat/commands/vote_to_mute/VoteToMuteStarter.java

@@ -42,7 +42,7 @@ public class VoteToMuteStarter {
     }
 
     public void start() {
-        chatLogHandler.retrieveChatLogs(votedPlayer.getUniqueId(), Duration.ofMinutes(5), serverName).whenCompleteAsync((chatLogs, throwable) -> {
+        chatLogHandler.retrieveChatLogs(votedPlayer.getUniqueId(), Duration.ofMinutes(10), serverName).whenCompleteAsync((chatLogs, throwable) -> {
             if (throwable != null) {
                 commandSource.sendMessage(Utility.parseMiniMessage("<prefix> <red>Unable to retrieve messages</red> for player <player>",
                         Placeholder.component("prefix", prefix),
@@ -52,40 +52,41 @@ public class VoteToMuteStarter {
             parseChatLogs(chatLogs);
             commandSource.sendMessage(Utility.parseMiniMessage(
                     "<prefix> <green>Please select up to 10 messages other players should see to decide their vote, seperated by comma's. " +
-                            "Example: <gold>/votetomutehelper messages 1, 2, 5, 8</gold></green>"));
-            showPage(0);
+                            "Example: <gold>/votetomutehelper messages 1, 2, 5, 8</gold></green>", Placeholder.component("prefix", prefix)));
+            showPage(1);
         });
     }
 
     private void parseChatLogs(List<ChatLog> chatLogs) {
         TagResolver.Single playerTag = Placeholder.parsed("player", votedPlayer.getUsername());
-        chatLogs.sort(Comparator.comparing(ChatLog::getTimestamp));
+        TagResolver.Single prefixTag = Placeholder.component("prefix", prefix);
+        chatLogs.sort(Comparator.comparing(ChatLog::getTimestamp).reversed());
         parsedChatLogs = IntStream.range(0, chatLogs.size())
                 .mapToObj(i -> Utility.parseMiniMessage(
-                        "<number>. [ChatLog] <player>: <message>",
+                        "<number>. <prefix> <player>: <message>",
                         TagResolver.resolver(
                                 Placeholder.unparsed("message", chatLogs.get(i).getMessage()),
                                 Placeholder.parsed("number", String.valueOf(i + 1)),
-                                playerTag
+                                playerTag, prefixTag
                         ))
                 )
                 .toList();
     }
 
     public void showPage(int page) {
-        List<Component> collect = parsedChatLogs.stream().skip(page * 10L).limit(page).toList();
+        List<Component> collect = parsedChatLogs.stream().skip((page - 1) * 10L).limit(10L).toList();
         Component chatLogsComponent = Component.join(JoinConfiguration.newlines(), collect);
         StringBuilder stringBuilder = new StringBuilder();
         stringBuilder.append("<prefix> ChatLogs for <player>\n<logs>\n");
-        if (page != 0) {
-            stringBuilder.append("<click:run_command:/votetomute page ")
+        if (page > 1) {
+            stringBuilder.append("<click:run_command:/votetomutehelper page ")
                     .append(page - 1)
                     .append("><hover:show_text:'<gold>Click to go to previous page'><gold><previous page></gold></hover></click> ");
         }
         if (parsedChatLogs.size() > page * 10) {
-            stringBuilder.append("<click:run_command:/votetomute page ")
+            stringBuilder.append("<click:run_command:/votetomutehelper page ")
                     .append(page + 1)
-                    .append("><hover:show_text:'<gold>Click to go to next page'><gold><previous page></gold></hover></click> ");
+                    .append("><hover:show_text:'<gold>Click to go to next page'><gold><next page></gold></hover></click> ");
         }
         commandSource.sendMessage(Utility.parseMiniMessage(stringBuilder.toString(),
                 Placeholder.parsed("player", votedPlayer.getUsername()),