Update APRIL_FOOLS_RESET string in Config class

APRIL_FOOLS_RESET string in Config class has been updated from "reverse" to "esrever". This change updates the behavior of the April Fools feature in the chat application.

Jenkinsfile

@@ -1,20 +0,0 @@
-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,12 +3,14 @@ plugins {
 }
 
 dependencies {
-//    compileOnly("com.alttd:Galaxy-API:1.21-R0.1-SNAPSHOT") {
+    compileOnly("com.alttd:Galaxy-API:1.19.2-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
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.0")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.7.0")
+    testImplementation("com.alttd:Galaxy-API:1.19.2-R0.1-SNAPSHOT")
 }
 
 publishing {
@@ -26,3 +28,7 @@ publishing {
         }
     }
 }
+
+tasks.test {
+    useJUnitPlatform()
+}

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(File.separator + "mnt" + File.separator + "configs" + File.separator + "ChatPlugin");
+        CONFIGPATH = new File(System.getProperty("user.home") + File.separator + "share" + File.separator + "configs" + File.separator + "ChatPlugin");
         CONFIG_FILE = new File(CONFIGPATH, "config.yml");
         configLoader = YamlConfigurationLoader.builder()
                 .file(CONFIG_FILE)
@@ -544,19 +544,8 @@ public final class Config {
         NICK_CURRENT = getString("nicknames.messages.nick-current", NICK_CURRENT);
     }
 
-    public static int DEATH_MESSAGES_MAX_PER_PERIOD = 5;
-    public static int DEATH_MESSAGES_LIMIT_PERIOD_MINUTES = 15;
-
-    private static void deathMessagesSettings() {
-        DEATH_MESSAGES_MAX_PER_PERIOD = getInt("death-messages.max-per-period", DEATH_MESSAGES_MAX_PER_PERIOD);
-        DEATH_MESSAGES_LIMIT_PERIOD_MINUTES = getInt("death-messages.limit-period-minutes", DEATH_MESSAGES_LIMIT_PERIOD_MINUTES);
-    }
-
-    public static long CHAT_LOG_DELETE_OLDER_THAN_DAYS = 31;
-    public static long CHAT_LOG_SAVE_DELAY_MINUTES = 5;
-
-    private static void chatLogSettings() {
-        CHAT_LOG_DELETE_OLDER_THAN_DAYS = getLong("chat-log.delete-older-than-days", CHAT_LOG_DELETE_OLDER_THAN_DAYS);
-        CHAT_LOG_SAVE_DELAY_MINUTES = getLong("chat-log.save-delay-minutes", CHAT_LOG_SAVE_DELAY_MINUTES);
+    public static String APRIL_FOOLS_RESET = "esrever";
+    private static void aprilFools() {
+        APRIL_FOOLS_RESET = getString("april-fools.reset", APRIL_FOOLS_RESET);
     }
 }

api/src/main/java/com/alttd/chat/database/ChatLogQueries.java

@@ -1,98 +0,0 @@
-package com.alttd.chat.database;
-
-import com.alttd.chat.objects.chat_log.ChatLog;
-import com.alttd.chat.objects.chat_log.ChatLogHandler;
-import com.alttd.chat.util.ALogger;
-import org.jetbrains.annotations.NotNull;
-
-import java.sql.*;
-import java.time.Duration;
-import java.time.Instant;
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionException;
-
-public class ChatLogQueries {
-
-    protected static void createChatLogTable() {
-        String nicknamesTableQuery = "CREATE TABLE IF NOT EXISTS chat_log("
-                + "uuid CHAR(48) NOT NULL,"
-                + "time_stamp TIMESTAMP(6) NOT NULL, "
-                + "server VARCHAR(50) NOT NULL, "
-                + "chat_message VARCHAR(300) NOT NULL, "
-                + "blocked BIT(1) NOT NULL DEFAULT 0"
-                + ")";
-
-        try (PreparedStatement preparedStatement = DatabaseConnection.getConnection().prepareStatement(nicknamesTableQuery)) {
-            preparedStatement.executeUpdate();
-        } catch (Throwable throwable) {
-            ALogger.error("Failed to create chat log table", throwable);
-        }
-    }
-
-    public static @NotNull CompletableFuture<Boolean> storeMessages(HashMap<UUID, List<ChatLog>> chatMessages) {
-        String insertQuery = "INSERT INTO chat_log (uuid, time_stamp, server, chat_message, blocked) VALUES (?, ?, ?, ?, ?)";
-        return CompletableFuture.supplyAsync(() -> {
-            try (Connection connection = DatabaseConnection.createTransactionConnection()) {
-                PreparedStatement preparedStatement = connection.prepareStatement(insertQuery);
-                for (List<ChatLog> chatLogList : chatMessages.values()) {
-                    for (ChatLog chatLog : chatLogList) {
-                        chatLog.prepareStatement(preparedStatement);
-                        preparedStatement.addBatch();
-                    }
-                }
-                int[] updatedRowsCount = preparedStatement.executeBatch();
-                boolean isSuccess = Arrays.stream(updatedRowsCount).allMatch(i -> i >= 0);
-
-                if (isSuccess) {
-                    connection.commit();
-                    return true;
-                } else {
-                    connection.rollback();
-                    ALogger.warn("Failed to store messages");
-                    return false;
-                }
-            } catch (SQLException sqlException) {
-                ALogger.error("Failed to store chat messages", sqlException);
-                throw new CompletionException("Failed to store chat messages", sqlException);
-            }
-        });
-    }
-
-    public static @NotNull CompletableFuture<List<ChatLog>> retrieveMessages(ChatLogHandler chatLogHandler, UUID uuid, Duration duration, String server) {
-        String query = "SELECT * FROM chat_log WHERE uuid = ? AND time_stamp > ? AND server = ?";
-        return CompletableFuture.supplyAsync(() -> {
-            try (Connection connection = DatabaseConnection.getConnection()) {
-                PreparedStatement preparedStatement = connection.prepareStatement(query);
-                preparedStatement.setString(1, uuid.toString());
-                preparedStatement.setTimestamp(2, Timestamp.from(Instant.now().minus(duration)));
-                preparedStatement.setString(3, server);
-                ResultSet resultSet = preparedStatement.executeQuery();
-                List<ChatLog> chatLogs = new ArrayList<>();
-                while (resultSet.next()) {
-                    ChatLog chatLog = chatLogHandler.loadFromResultSet(resultSet);
-                    chatLogs.add(chatLog);
-                }
-                return chatLogs;
-            } catch (SQLException sqlException) {
-                ALogger.error(String.format("Failed to retrieve messages for user %s", uuid), sqlException);
-                throw new CompletionException(String.format("Failed to retrieve messages for user %s", uuid), sqlException);
-            }
-        });
-    }
-
-    public static CompletableFuture<Boolean> deleteOldMessages(Duration duration) {
-        String query = "DELETE FROM chat_log WHERE time_stamp < ?";
-
-        return CompletableFuture.supplyAsync(() -> {
-            try (Connection connection = DatabaseConnection.getConnection()) {
-                PreparedStatement preparedStatement = connection.prepareStatement(query);
-                preparedStatement.setTimestamp(1, Timestamp.from(Instant.now().minus(duration)));
-                return preparedStatement.execute();
-            } catch (SQLException sqlException) {
-                ALogger.error(String.format("Failed to delete messages older than %s days", duration.toDays()), sqlException);
-                throw new CompletionException(String.format("Failed to delete messages older than %s days", duration.toDays()), sqlException);
-            }
-        });
-    }
-}

api/src/main/java/com/alttd/chat/database/DatabaseConnection.java

@@ -2,6 +2,7 @@ package com.alttd.chat.database;
 
 
 import com.alttd.chat.config.Config;
+import com.alttd.chat.util.ALogger;
 
 import java.sql.Connection;
 import java.sql.DriverManager;
@@ -65,21 +66,6 @@ public class DatabaseConnection {
         return connection;
     }
 
-    /**
-     * Creates a transactional database connection.
-     *
-     * @return A {@code Connection} object representing the transactional database connection.
-     * @throws SQLException If there is an error creating the database connection.
-     */
-    public static Connection createTransactionConnection() throws SQLException {
-        connection = DriverManager.getConnection(
-                "jdbc:mysql://" + Config.IP + ":" + Config.PORT + "/" + Config.DATABASE + "?autoReconnect=true"+
-                        "&useSSL=false",
-                Config.USERNAME, Config.PASSWORD);
-        connection.setAutoCommit(false);
-        return connection;
-    }
-
     /**
      * Sets the connection for this instance
      */

api/src/main/java/com/alttd/chat/database/Queries.java

@@ -21,7 +21,6 @@ public class Queries {
         tables.add("CREATE TABLE IF NOT EXISTS mails (`id` INT NOT NULL AUTO_INCREMENT, `uuid` VARCHAR(36) NOT NULL, `sender` VARCHAR(36) NOT NULL, `message` VARCHAR(256) NOT NULL, `sendtime` BIGINT default 0, `readtime` BIGINT default 0, PRIMARY KEY (`id`))");
         createNicknamesTable();
         createRequestedNicknamesTable();
-        ChatLogQueries.createChatLogTable();
         try {
             Connection connection = DatabaseConnection.getConnection();
 

api/src/main/java/com/alttd/chat/objects/BatchInsertable.java

@@ -1,10 +0,0 @@
-package com.alttd.chat.objects;
-
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-
-public interface BatchInsertable {
-
-    void prepareStatement(PreparedStatement preparedStatement) throws SQLException;
-
-}

api/src/main/java/com/alttd/chat/objects/ModifiableString.java

@@ -1,12 +1,14 @@
 package com.alttd.chat.objects;
 
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.TextComponent;
 import net.kyori.adventure.text.TextReplacementConfig;
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
-import org.intellij.lang.annotations.RegExp;
 
-import javax.annotation.RegEx;
-import java.util.regex.Pattern;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
 
 public class ModifiableString {
     private Component text;
@@ -30,4 +32,37 @@ public class ModifiableString {
     public Component component() {
         return text;
     }
+
+    public void reverse() {
+        text = reverseComponent(text);
+    }
+
+    public Component reverseComponent(Component component) {
+        if (!(component instanceof TextComponent textComponent)) {
+            return Component.text("")
+                    .append(Component.join(JoinConfiguration.noSeparators(), reverseChildren(component.children())));
+        }
+
+        String content = textComponent.content();
+        String reversedContent = new StringBuilder(content).reverse().toString();
+
+        List<Component> reversedChildren = reverseChildren(component.children());
+
+        return Component.text("")
+                .append(Component.join(JoinConfiguration.noSeparators(), reversedChildren)
+                        .append(Component.text(reversedContent, component.style())));
+    }
+
+    public List<Component> reverseChildren(List<Component> children) {
+        return children.stream()
+                .map(this::reverseComponent)
+                .collect(Collectors.collectingAndThen(Collectors.toList(), list -> {
+                    Collections.reverse(list);
+                    return list;
+                }));
+    }
+
+    public void removeStringAtStart(String s) {
+        text = text.replaceText(TextReplacementConfig.builder().match("^" + s).replacement("").build());
+    }
 }

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

@@ -1,52 +0,0 @@
-package com.alttd.chat.objects.chat_log;
-
-import com.alttd.chat.objects.BatchInsertable;
-import org.jetbrains.annotations.NotNull;
-
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.time.Instant;
-import java.util.UUID;
-
-public class ChatLog implements BatchInsertable {
-
-    private final UUID uuid;
-    private final Instant timestamp;
-    private final String server;
-    private final String message;
-    private final boolean blocked;
-
-    protected ChatLog(UUID uuid, Instant timestamp, String server, String message, boolean blocked) {
-        this.uuid = uuid;
-        this.timestamp = timestamp;
-        this.server = server;
-        this.message = message;
-        this.blocked = blocked;
-    }
-
-    @Override
-    public void prepareStatement(@NotNull PreparedStatement preparedStatement) throws SQLException {
-        preparedStatement.setString(1, uuid.toString());
-        preparedStatement.setTimestamp(2, Timestamp.from(timestamp));
-        preparedStatement.setString(3, server);
-        preparedStatement.setString(4, message);
-        preparedStatement.setInt(5, blocked ? 1 : 0);
-    }
-
-    public UUID getUuid() {
-        return uuid;
-    }
-
-    public Instant getTimestamp() {
-        return timestamp;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-    public boolean isBlocked() {
-        return blocked;
-    }
-}

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

@@ -1,128 +0,0 @@
-package com.alttd.chat.objects.chat_log;
-
-import com.alttd.chat.config.Config;
-import com.alttd.chat.database.ChatLogQueries;
-import com.alttd.chat.util.ALogger;
-import org.jetbrains.annotations.NotNull;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.time.Duration;
-import java.time.Instant;
-import java.util.*;
-import java.util.concurrent.*;
-
-public class ChatLogHandler {
-
-    private static ChatLogHandler instance = null;
-    private ScheduledExecutorService executorService = null;
-
-    public static ChatLogHandler getInstance(boolean enableLogging) {
-        if (instance == null)
-            instance = new ChatLogHandler(enableLogging);
-        return instance;
-    }
-
-    private boolean isSaving;
-    private final Queue<ChatLog> chatLogQueue = new ConcurrentLinkedQueue<>();
-    private final HashMap<UUID, List<ChatLog>> chatLogs = new HashMap<>();
-
-    public ChatLogHandler(boolean 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) {
-                ALogger.info(String.format("Deleted all messages older than %s days from chat log database.", deleteThreshold.toDays()));
-            } else {
-                ALogger.warn(String.format("Failed to delete all messages older than %s days from chat log database.", deleteThreshold.toDays()));
-            }
-        });
-        executorService = Executors.newSingleThreadScheduledExecutor();
-        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!");
-    }
-
-    /**
-     * Shuts down the executor service and saves the chat logs to the database.
-     * Will throw an error if called on a ChatLogHandler that was started without logging
-     */
-    public void shutDown() {
-        executorService.shutdown();
-        saveToDatabase(true);
-    }
-
-    private synchronized void savingToDatabase(boolean saving) {
-        isSaving = saving;
-    }
-
-    private synchronized boolean isBlocked() {
-        return isSaving;
-    }
-
-    public synchronized void addLog(ChatLog chatLog) {
-        if (isBlocked()) {
-            chatLogQueue.add(chatLog);
-        } else {
-            chatLogs.computeIfAbsent(chatLog.getUuid(), k -> new ArrayList<>()).add(chatLog);
-        }
-    }
-
-    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");
-        });
-    }
-
-    public ChatLog loadFromResultSet(@NotNull ResultSet resultSet) throws SQLException {
-        UUID chatLogUUID = UUID.fromString(resultSet.getString("uuid"));
-        Instant chatTimestamp = resultSet.getTimestamp("time_stamp").toInstant();
-        String server = resultSet.getString("server");
-        String chatMessage = resultSet.getString("chat_message");
-        boolean chatMessageBlocked = resultSet.getInt("blocked") == 1;
-        return new ChatLog(chatLogUUID, chatTimestamp, server, chatMessage, chatMessageBlocked);
-    }
-
-    public void addChatLog(UUID uuid, String server, String message, boolean blocked) {
-        addLog(new ChatLog(uuid, Instant.now(), server, message, blocked));
-    }
-
-    public CompletableFuture<List<ChatLog>> retrieveChatLogs(UUID uuid, Duration duration, String server) {
-        List<ChatLog> chatLogList = chatLogs.getOrDefault(uuid, new ArrayList<>());
-        return ChatLogQueries.retrieveMessages(this, uuid, duration, server)
-                .thenCompose(chatLogs -> CompletableFuture.supplyAsync(() -> {
-                    chatLogList.addAll(chatLogs);
-                    return chatLogList;
-                }))
-                .exceptionally(ex -> {
-                    throw new CompletionException(ex);
-                });
-    }
-
-}

api/src/main/java/com/alttd/chat/util/ALogger.java

@@ -16,10 +16,6 @@ public class ALogger {
         logger.warn(message);
     }
 
-    public static void warn(String message, Throwable throwable) {
-        logger.warn(message, throwable);
-    }
-
     public static void info(String message) {
         logger.info(message);
     }
@@ -27,8 +23,4 @@ public class ALogger {
     public static void error(String message) {
         logger.error(message);
     }
-
-    public static void error(String message, Throwable throwable) {
-        logger.error(message, throwable);
-    }
 }

api/src/test/java/ReverseTest.java

@@ -0,0 +1,86 @@
+import com.alttd.chat.config.Config;
+import com.alttd.chat.objects.ModifiableString;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+public class ReverseTest {
+
+    @Test
+    public void testReverseString() {
+        String input = "Hello how are you doing today?";
+        String expectedOutput = new StringBuilder(input).reverse().toString();
+        MiniMessage miniMessage = MiniMessage.miniMessage();
+        ModifiableString modifiableString = new ModifiableString(miniMessage.deserialize(input));
+        modifiableString.reverse();
+        assertEquals(expectedOutput, modifiableString.string());
+    }
+
+    @Test
+    public void testRemoveKeyword() {
+        String input = "Hello how are you doing today?";
+        MiniMessage miniMessage = MiniMessage.miniMessage();
+
+        ModifiableString modifiableString = new ModifiableString(miniMessage.deserialize(Config.APRIL_FOOLS_RESET + " " + input));
+        modifiableString.removeStringAtStart(Config.APRIL_FOOLS_RESET + " ");
+
+        assertEquals(input, modifiableString.string());
+    }
+
+    @Test
+    public void testRemoveKeywordWithTags() {
+        MiniMessage miniMessage = MiniMessage.miniMessage();
+        String input = "<blue>" + Config.APRIL_FOOLS_RESET + " <red>Hello how are</red> you <blue>doing today</blue>?</blue>";
+        String expectedOutput = "Hello how are you doing today?";
+        Component deserialize = miniMessage.deserialize(input);
+
+        ModifiableString modifiableString = new ModifiableString(deserialize);
+        modifiableString.removeStringAtStart(Config.APRIL_FOOLS_RESET + " ");
+
+        assertEquals(expectedOutput, modifiableString.string());
+    }
+
+
+    @Test
+    public void testReverseStringWithTags() {
+        String input = "<red>Hello how are</red> you <blue>doing today</blue>?";
+        MiniMessage miniMessage = MiniMessage.miniMessage();
+        Component deserialize = miniMessage.deserialize(input);
+        ModifiableString modifiableString = new ModifiableString(deserialize);
+        String expectedOutput = new StringBuilder(PlainTextComponentSerializer.plainText().serialize(deserialize)).reverse().toString();
+        modifiableString.reverse();
+        assertEquals(expectedOutput, modifiableString.string());
+    }
+
+    @Test
+    public void complexTestReverseStringWithTags() {
+        String input = "<green><red>Hello <b>how</b> are</red> you <blue>doing today</blue><gold>?</gold></green>";
+        MiniMessage miniMessage = MiniMessage.miniMessage();
+        Component deserialize = miniMessage.deserialize(input);
+        ModifiableString modifiableString = new ModifiableString(deserialize);
+        String expectedOutput = new StringBuilder(PlainTextComponentSerializer.plainText().serialize(deserialize)).reverse().toString();
+        modifiableString.reverse();
+        assertEquals(expectedOutput, modifiableString.string());
+    }
+
+    @Test
+    public void extraComplexTestReverseStringWithTags() {
+        String input = "<gold>This <red>is</red> longer<green> <name> <red>Hello <b>how</b> are</red> you <test> <blue>doing <name> today</blue><gold>?</gold></green></gold>";
+        MiniMessage miniMessage = MiniMessage.miniMessage();
+        Component deserialize = miniMessage.deserialize(input, TagResolver.resolver(
+                Placeholder.component("name", miniMessage.deserialize("<red>Cool<blue><rainbow>_player_</rainbow>name</red>")),
+                Placeholder.parsed("test", "test replacement")
+        ));
+        ModifiableString modifiableString = new ModifiableString(deserialize);
+        String expectedOutput = new StringBuilder(PlainTextComponentSerializer.plainText().serialize(deserialize)).reverse().toString();
+        modifiableString.reverse();
+        System.out.println(expectedOutput);
+        assertEquals(expectedOutput, modifiableString.string());
+    }
+
+}

build.gradle.kts

@@ -1,12 +1,25 @@
 plugins {
     `java-library`
-    id("io.github.goooler.shadow") version "8.1.8"
+    id("com.github.johnrengelman.shadow") version "7.1.0"
 }
 
 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 {
@@ -14,7 +27,7 @@ subprojects {
 
     java {
         toolchain {
-            languageVersion.set(JavaLanguageVersion.of(21))
+            languageVersion.set(JavaLanguageVersion.of(17))
         }
     }
 

galaxy/build.gradle.kts

@@ -1,25 +1,58 @@
+import java.io.FileOutputStream
+import java.net.URL
+
 plugins {
     `maven-publish`
-    id("io.github.goooler.shadow")
+    id("com.github.johnrengelman.shadow")
+    id("xyz.jpenilla.run-paper") version "1.0.6"
 }
 
 dependencies {
     implementation(project(":api")) // API
-//    compileOnly("com.alttd:Galaxy-API:1.21-R0.1-SNAPSHOT") // Galaxy
-    compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
+    compileOnly("com.alttd:Galaxy-API:1.20.4-R0.1-SNAPSHOT") // Galaxy
     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

@@ -5,12 +5,14 @@ import com.alttd.chat.config.Config;
 import com.alttd.chat.config.ServerConfig;
 import com.alttd.chat.database.DatabaseConnection;
 import com.alttd.chat.handler.ChatHandler;
-import com.alttd.chat.listeners.*;
+import com.alttd.chat.listeners.BookListener;
+import com.alttd.chat.listeners.ChatListener;
+import com.alttd.chat.listeners.PlayerListener;
+import com.alttd.chat.listeners.PluginMessage;
 import com.alttd.chat.nicknames.Nicknames;
 import com.alttd.chat.nicknames.NicknamesEvents;
 import com.alttd.chat.objects.channels.Channel;
 import com.alttd.chat.objects.channels.CustomChannel;
-import com.alttd.chat.objects.chat_log.ChatLogHandler;
 import com.alttd.chat.util.ALogger;
 import com.alttd.chat.util.Utility;
 import org.bukkit.Bukkit;
@@ -38,9 +40,8 @@ public class ChatPlugin extends JavaPlugin {
         chatAPI = new ChatImplementation();
         chatHandler = new ChatHandler();
         DatabaseConnection.initialize();
-        serverConfig = new ServerConfig(Bukkit.getServer().getName());
-        ChatLogHandler chatLogHandler = ChatLogHandler.getInstance(true);
-        registerListener(new PlayerListener(serverConfig), new ChatListener(chatLogHandler), new BookListener(), new ShutdownListener(chatLogHandler, this));
+        serverConfig = new ServerConfig(Bukkit.getServerName());
+        registerListener(new PlayerListener(serverConfig), new ChatListener(), new BookListener());
         if(serverConfig.GLOBALCHAT) {
             registerCommand("globalchat", new GlobalChat());
             registerCommand("toggleglobalchat", new ToggleGlobalChat());
@@ -119,7 +120,7 @@ public class ChatPlugin extends JavaPlugin {
     public void ReloadConfig() {
         chatAPI.ReloadConfig();
         chatAPI.ReloadChatFilters();
-        serverConfig = new ServerConfig(Bukkit.getServer().getName());
+        serverConfig = new ServerConfig(Bukkit.getServerName());
         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.sendRichMessage(Config.CUSTOM_CHANNEL_TOGGLED, TagResolver.resolver(
+            player.sendMiniMessage(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.sendRichMessage(Config.PARTY_TOGGLED, Placeholder.component("status",
+            player.sendMiniMessage(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,7 +26,6 @@ import org.bukkit.inventory.ItemStack;
 
 import java.util.*;
 import java.util.concurrent.TimeUnit;
-import java.util.stream.Stream;
 
 public class ChatHandler {
 
@@ -131,7 +130,7 @@ public class ChatHandler {
                 Placeholder.component("sender", senderName),
                 Placeholder.component("prefix", prefix),
                 Placeholder.component("message", parseMessageContent(player, message)),
-                Placeholder.parsed("server", Bukkit.getServer().getName())
+                Placeholder.parsed("server", Bukkit.getServerName())
         );
 
         Component component = Utility.parseMiniMessage(Config.GCFORMAT, placeholders);
@@ -165,7 +164,7 @@ public class ChatHandler {
         TagResolver placeholders = TagResolver.resolver(
                 Placeholder.component("sender", senderName),
                 Placeholder.component("message", parseMessageContent(player, message)),
-                Placeholder.parsed("server", Bukkit.getServer().getName()),
+                Placeholder.parsed("server", Bukkit.getServerName()),
                 Placeholder.parsed("channel", channel.getChannelName())
         );
         Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders);
@@ -238,21 +237,12 @@ public class ChatHandler {
     }
 
     private void sendChatChannelMessage(CustomChannel chatChannel, UUID uuid, Component component) {
-        if (!chatChannel.getServers().contains(Bukkit.getServer().getName())) {
-            return;
-        }
+        if (!chatChannel.getServers().contains(Bukkit.getServerName())) return;
 
-        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));
+        Bukkit.getServer().getOnlinePlayers().stream()
+                .filter(p -> p.hasPermission(chatChannel.getPermission()))
+                .filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers().contains(uuid))
+                .forEach(p -> p.sendMessage(component));
     }
 
     private void sendPluginMessage(Player player, String channel, Component component) {

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

@@ -6,7 +6,6 @@ import com.alttd.chat.handler.ChatHandler;
 import com.alttd.chat.managers.ChatUserManager;
 import com.alttd.chat.managers.RegexManager;
 import com.alttd.chat.objects.*;
-import com.alttd.chat.objects.chat_log.ChatLogHandler;
 import com.alttd.chat.util.ALogger;
 import com.alttd.chat.util.GalaxyUtility;
 import com.alttd.chat.util.Utility;
@@ -30,21 +29,15 @@ import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.jetbrains.annotations.NotNull;
 
+import java.time.*;
 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 {
 
     private final PlainTextComponentSerializer plainTextComponentSerializer = PlainTextComponentSerializer.plainText();
-    private final ChatLogHandler chatLogHandler;
-
-    public ChatListener(ChatLogHandler chatLogHandler) {
-        this.chatLogHandler = chatLogHandler;
-    }
 
 
     @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
@@ -83,14 +76,18 @@ public class ChatListener implements Listener {
         }
 
         Player player = event.getPlayer();
-        UUID uuid = player.getUniqueId();
+
+        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());
 
         Component input = event.message().colorIfAbsent(NamedTextColor.WHITE);
 
         ModifiableString modifiableString = new ModifiableString(input);
 
          // todo a better way for this
-        if(!RegexManager.filterText(player.getName(), uuid, modifiableString, true, "chat", filterType -> {
+        if(!RegexManager.filterText(player.getName(), player.getUniqueId(), 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;
@@ -98,7 +95,7 @@ public class ChatListener implements Listener {
             ByteArrayDataOutput out = ByteStreams.newDataOutput();
             out.writeUTF("punish");
             out.writeUTF(player.getName());
-            out.writeUTF(uuid.toString());
+            out.writeUTF(player.getUniqueId().toString());
             out.writeUTF(modifiableString.string());
             player.sendPluginMessage(ChatPlugin.getInstance(), Config.MESSAGECHANNEL, out.toByteArray());
         })) {
@@ -106,22 +103,19 @@ public class ChatListener implements Listener {
             GalaxyUtility.sendBlockedNotification("Language", player,
                     modifiableString.component(),
                     "");
-            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);
-
+        LocalDate now = LocalDate.now();
+        if (now.getMonth().equals(Month.APRIL) && now.getDayOfMonth() == 1) {
+            if (modifiableString.string().startsWith(Config.APRIL_FOOLS_RESET + " ")) {
+                modifiableString.removeStringAtStart(Config.APRIL_FOOLS_RESET + " ");
+            } else {
+                modifiableString.reverse();
+            }
+        }
         input = render(player, modifiableString.component());
         for (Player receiver : receivers) {
             receiver.sendMessage(input);
@@ -129,7 +123,6 @@ public class ChatListener implements Listener {
         for (Player pingPlayer : playersToPing) {
             pingPlayer.playSound(pingPlayer.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1);
         }
-        chatLogHandler.addChatLog(uuid, player.getServer().getName(), modifiableString.string(), false);
         ALogger.info(PlainTextComponentSerializer.plainText().serialize(input));
     }
 
@@ -143,12 +136,11 @@ 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(onlinePlayerUser.getDisplayName()))
+                        .replacement(mention.append(onlinePlayer.displayName()))
                         .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()
@@ -158,17 +150,15 @@ public class ChatListener implements Listener {
 //                            String substring = a.group().substring(1);
 //                            return ;
 //                        });
-                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
-                    && !player.hasPermission("chat.ignorebypass"))
+                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId()))
                     playersToPing.add(onlinePlayer);
             } else if (nickPattern.matcher(modifiableString.string()).find()) {
                 modifiableString.replace(TextReplacementConfig.builder()
                         .once()
                         .match(nickPattern)
-                        .replacement(mention.append(onlinePlayerUser.getDisplayName()))
+                        .replacement(mention.append(onlinePlayer.displayName()))
                         .build());
-                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
-                    && !player.hasPermission("chat.ignorebypass"))
+                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId()))
                     playersToPing.add(onlinePlayer);
             }
         }
@@ -219,4 +209,4 @@ public class ChatListener implements Listener {
 
     }
 
-}
+}

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

@@ -11,27 +11,15 @@ 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;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.SignChangeEvent;
-import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
-import org.jetbrains.annotations.NotNull;
 
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.HashMap;
-import java.util.Stack;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
@@ -50,8 +38,8 @@ public class PlayerListener implements Listener {
         UUID uuid = player.getUniqueId();
         Toggleable.disableToggles(uuid);
 
-        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())));
+        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())));
         }
 
         ChatUser user = ChatUserManager.getChatUser(uuid);
@@ -98,43 +86,4 @@ public class PlayerListener implements Listener {
         }
     }
 
-    private final HashMap<UUID, Stack<Instant>> sendPlayerDeaths = new HashMap<>();
-    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
-    public void onPlayerDeath(@NotNull PlayerDeathEvent event) {
-        UUID uuid = event.getPlayer().getUniqueId();
-        Stack<Instant> playerDeathsStack = sendPlayerDeaths.computeIfAbsent(uuid, key -> new Stack<>());
-        Instant cutOff = Instant.now().minus(Config.DEATH_MESSAGES_LIMIT_PERIOD_MINUTES, ChronoUnit.MINUTES);
-
-        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;
-        }
-            Component component = event.deathMessage();
-
-        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, @NotNull Player ignored, byte[] bytes) {
+    public void onPluginMessageReceived(String channel, Player player, byte[] bytes) {
         if (!channel.equals(Config.MESSAGECHANNEL)) {
             return;
         }
@@ -38,36 +38,35 @@ public class PluginMessage implements PluginMessageListener {
             case "privatemessagein": {
                 UUID uuid = UUID.fromString(in.readUTF());
                 String target = in.readUTF();
-                Player player = Bukkit.getPlayer(uuid);
+                Player p = Bukkit.getPlayer(uuid);
                 String message = in.readUTF();
                 UUID targetuuid = UUID.fromString(in.readUTF());
-                if (player == null) {
-                    break;
-                }
-                ChatUser chatUser = ChatUserManager.getChatUser(uuid);
-                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);
+                if (p != null) {
+                    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
+                        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 player = Bukkit.getPlayer(uuid);
+                Player p = Bukkit.getPlayer(uuid);
                 String message = in.readUTF();
                 UUID targetuuid = UUID.fromString(in.readUTF());
-                if (player == null) {
-                    break;
-                }
-                ChatUser chatUser = ChatUserManager.getChatUser(uuid);
-                if (isTargetNotIgnored(chatUser, targetuuid)) {
-                    chatUser.setReplyTarget(target);
-                    player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
+                if (p != null) {
+                    ChatUser chatUser = ChatUserManager.getChatUser(uuid);
+                    if (!chatUser.getIgnoredPlayers().contains(targetuuid)) {
+                        chatUser.setReplyTarget(target);
+                        p.sendMessage(GsonComponentSerializer.gson().deserialize(message));
 //                        ChatUser user = ChatUserManager.getChatUser(uuid);
 //                        user.setReplyTarget(target);
+                    }
                 }
                 break;
             }
@@ -79,7 +78,7 @@ public class PluginMessage implements PluginMessageListener {
 
                 Bukkit.getOnlinePlayers().stream().filter(p -> p.hasPermission(Config.GCPERMISSION)).forEach(p -> {
                     ChatUser chatUser = ChatUserManager.getChatUser(p.getUniqueId());
-                    if (isTargetNotIgnored(chatUser, uuid)) {
+                    if (!chatUser.getIgnoredPlayers().contains(uuid)) {
                         p.sendMessage(GsonComponentSerializer.gson().deserialize(message));
                     }
                 });
@@ -194,7 +193,7 @@ public class PluginMessage implements PluginMessageListener {
             ALogger.warn("Received ChatChannel message for non existent channel.");
             return;
         }
-        if (!chatChannel.getServers().contains(Bukkit.getServer().getName())) {
+        if (!chatChannel.getServers().contains(Bukkit.getServerName())) {
             ALogger.warn("Received ChatChannel message for the wrong server.");
             return;
         }
@@ -217,15 +216,4 @@ 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

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

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

@@ -1,5 +1,7 @@
 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;
@@ -11,6 +13,7 @@ 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;
@@ -111,7 +114,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
                                 Placeholder.component("nickname", chatUser.getDisplayName()),
                                 Placeholder.parsed("currentnickname", chatUser.getNickNameString())
                         );
-                        player.sendRichMessage(Config.NICK_CURRENT, placeholders);
+                        player.sendMiniMessage(Config.NICK_CURRENT, placeholders);
                     }
                     break;
                 case "help":
@@ -381,7 +384,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) {
@@ -396,25 +399,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,8 +1,12 @@
 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,7 +41,6 @@ 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,14 +4,11 @@ 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
@@ -19,14 +16,6 @@ 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("io.github.goooler.shadow")
+    id("com.github.johnrengelman.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.1-SNAPSHOT")
+    compileOnly("com.alttd.proxydiscordlink:ProxyDiscordLink:1.0.0-BETA-SNAPSHOT")
 }
 
 tasks {
@@ -30,4 +30,4 @@ tasks {
         dependsOn(shadowJar)
     }
 
-}
+}

velocity/src/main/java/com/alttd/velocitychat/VelocityChat.java

@@ -5,7 +5,6 @@ import com.alttd.chat.ChatImplementation;
 import com.alttd.chat.managers.ChatUserManager;
 import com.alttd.chat.managers.PartyManager;
 import com.alttd.chat.objects.ChatUser;
-import com.alttd.chat.objects.chat_log.ChatLogHandler;
 import com.alttd.velocitychat.commands.*;
 import com.alttd.chat.config.Config;
 import com.alttd.chat.database.DatabaseConnection;
@@ -24,7 +23,6 @@ import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.plugin.Dependency;
 import com.velocitypowered.api.plugin.Plugin;
 import com.velocitypowered.api.plugin.annotation.DataDirectory;
-import com.velocitypowered.api.proxy.ConsoleCommandSource;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
 import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
@@ -110,14 +108,11 @@ public class VelocityChat {
     }
 
     public void loadCommands() {
-        ChatLogHandler instance = ChatLogHandler.getInstance(false);
         new SilentJoinCommand(server);
         new GlobalAdminChat(server);
         new Reload(server);
         new MailCommand(server);
         new Report(server);
-        new VoteToMute(server, instance);
-        new VoteToMuteHelper(server);
         server.getCommandManager().register("party", new PartyCommand());
         // all (proxy)commands go here
     }

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

@@ -1,163 +0,0 @@
-package com.alttd.velocitychat.commands;
-
-import com.alttd.chat.objects.chat_log.ChatLogHandler;
-import com.alttd.chat.util.Utility;
-import com.alttd.velocitychat.commands.vote_to_mute.VoteToMuteStarter;
-import com.mojang.brigadier.arguments.StringArgumentType;
-import com.mojang.brigadier.builder.LiteralArgumentBuilder;
-import com.mojang.brigadier.builder.RequiredArgumentBuilder;
-import com.mojang.brigadier.suggestion.Suggestions;
-import com.mojang.brigadier.tree.LiteralCommandNode;
-import com.velocitypowered.api.command.BrigadierCommand;
-import com.velocitypowered.api.command.CommandMeta;
-import com.velocitypowered.api.command.CommandSource;
-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 net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-public class VoteToMute {
-
-    public VoteToMute(ProxyServer proxyServer, ChatLogHandler chatLogHandler) {
-        RequiredArgumentBuilder<CommandSource, String> playerNode = RequiredArgumentBuilder
-                .<CommandSource, String>argument("player", StringArgumentType.string())
-                .suggests((context, builder) -> {
-                    List<Player> possiblePlayers;
-                    if (context.getSource() instanceof Player player) {
-                        Optional<ServerConnection> currentServer = player.getCurrentServer();
-                        if (currentServer.isPresent()) {
-                            possiblePlayers = getEligiblePlayers(currentServer.get().getServer());
-                        } else {
-                            possiblePlayers = getEligiblePlayers(proxyServer);
-                        }
-                    } else {
-                        possiblePlayers = getEligiblePlayers(proxyServer);
-                    }
-                    Collection<String> possibleValues = possiblePlayers.stream()
-                            .map(Player::getUsername)
-                            .toList();
-
-                    if (possibleValues.isEmpty())
-                        return Suggestions.empty();
-
-                    String remaining = builder.getRemaining().toLowerCase();
-                    possibleValues.stream()
-                            .filter(str -> str.toLowerCase().startsWith(remaining))
-                            .map(StringArgumentType::escapeIfRequired)
-                            .forEach(builder::suggest);
-                    return builder.buildFuture();
-                })
-                .executes(context -> {
-                    sendHelpMessage(context.getSource());
-                    return 1;
-                });
-
-        LiteralCommandNode<CommandSource> command = LiteralArgumentBuilder
-                .<CommandSource>literal("votetomute")
-                .requires(commandSource -> commandSource.hasPermission("chat.vote-to-mute"))
-                .requires(commandSource -> commandSource instanceof Player)
-                .then(playerNode
-                        .suggests(((commandContext, suggestionsBuilder) -> {
-                            if (!(commandContext.getSource() instanceof Player player)) {
-                                return suggestionsBuilder.buildFuture();
-                            }
-                            Optional<ServerConnection> currentServer = player.getCurrentServer();
-                            if (currentServer.isEmpty()) {
-                                sendHelpMessage(commandContext.getSource());
-                                return suggestionsBuilder.buildFuture();
-                            }
-                            String remaining = suggestionsBuilder.getRemaining().toLowerCase();
-                            currentServer.get().getServer().getPlayersConnected().stream()
-                                    .filter(connectedPlayer -> connectedPlayer.hasPermission("chat.affected-by-vote-to-mute"))
-                                    .map(Player::getUsername)
-                                    .filter((String str) -> str.toLowerCase().startsWith(remaining))
-                                    .map(StringArgumentType::escapeIfRequired)
-                                    .forEach(suggestionsBuilder::suggest);
-                            return suggestionsBuilder.buildFuture();
-                        }))
-                        .executes(commandContext -> {
-                            String playerName = commandContext.getArgument("player", String.class);
-                            Optional<Player> optionalPlayer = proxyServer.getPlayer(playerName);
-                            if (optionalPlayer.isEmpty()) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage(
-                                        "<red>Player <player> is not online.</red>",
-                                        Placeholder.parsed("player", playerName)));
-                                return 1;
-                            }
-                            Player voteTarget = optionalPlayer.get();
-                            if (!voteTarget.hasPermission("chat.affected-by-vote-to-mute")) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage(
-                                        "<red>Player <player> can not be muted by a vote.</red>",
-                                        Placeholder.parsed("player", playerName)));
-                                return 1;
-                            }
-                            Player player = (Player) commandContext.getSource();
-                            Optional<ServerConnection> currentServer = player.getCurrentServer();
-                            if (currentServer.isEmpty()) {
-                                sendHelpMessage(commandContext.getSource());
-                                return 1;
-                            }
-                            RegisteredServer server = currentServer.get().getServer();
-                            if (currentServer.get().getServer().getPlayersConnected().stream().anyMatch(onlinePlayer -> onlinePlayer.hasPermission("chat.staff"))) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>There is a staff member online, so vote to mute can not be used. Please contact a staff member for help instead.</red>"));
-                                return 1;
-                            }
-                            boolean countLowerRanks = false;
-                            long count = getTotalEligiblePlayers(server, false);
-                            if (count < 6) {
-                                countLowerRanks = true;
-                                count = getTotalEligiblePlayers(server, true);
-                                if (count < 6) {
-                                    commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Not enough eligible players online to vote.</red>"));
-                                    return 1;
-                                }
-                            }
-                            new VoteToMuteStarter(chatLogHandler, voteTarget, player, server.getServerInfo().getName(), countLowerRanks)
-                                    .start();
-                            return 1;
-                        }))
-                .executes(context -> {
-                    sendHelpMessage(context.getSource());
-                    return 1;
-                })
-                .build();
-
-        BrigadierCommand brigadierCommand = new BrigadierCommand(command);
-
-        CommandMeta.Builder metaBuilder = proxyServer.getCommandManager().metaBuilder(brigadierCommand);
-
-        CommandMeta meta = metaBuilder.build();
-
-        proxyServer.getCommandManager().register(meta, brigadierCommand);
-    }
-
-    private int getTotalEligiblePlayers(RegisteredServer server, boolean countLowerRanks) {
-        return (int) server.getPlayersConnected().stream()
-                .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
-                .count();
-    }
-
-    private void sendHelpMessage(CommandSource commandSource) {
-        commandSource.sendMessage(Utility.parseMiniMessage("<red>Use: <gold>/votetomute <player></gold>.</red>"));
-    }
-
-    private List<Player> getEligiblePlayers(ProxyServer proxyServer) {
-        return proxyServer.getAllPlayers().stream()
-                .filter(player -> player.hasPermission("chat.affected-by-vote-to-mute"))
-                .collect(Collectors.toList());
-    }
-
-    private List<Player> getEligiblePlayers(RegisteredServer registeredServer) {
-        return registeredServer.getPlayersConnected().stream()
-                .filter(player -> player.hasPermission("chat.affected-by-vote-to-mute"))
-                .collect(Collectors.toList());
-
-    }
-
-}

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

@@ -1,285 +0,0 @@
-package com.alttd.velocitychat.commands;
-
-import com.alttd.chat.util.Utility;
-import com.alttd.velocitychat.commands.vote_to_mute.ActiveVoteToMute;
-import com.alttd.velocitychat.commands.vote_to_mute.VoteToMuteStarter;
-import com.mojang.brigadier.arguments.IntegerArgumentType;
-import com.mojang.brigadier.arguments.StringArgumentType;
-import com.mojang.brigadier.builder.LiteralArgumentBuilder;
-import com.mojang.brigadier.builder.RequiredArgumentBuilder;
-import com.mojang.brigadier.suggestion.Suggestions;
-import com.mojang.brigadier.tree.LiteralCommandNode;
-import com.velocitypowered.api.command.BrigadierCommand;
-import com.velocitypowered.api.command.CommandMeta;
-import com.velocitypowered.api.command.CommandSource;
-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;
-
-import java.time.Duration;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-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())
-                .suggests((context, builder) -> {
-                    List<Player> possiblePlayers;
-                    if (context.getSource() instanceof Player player) {
-                        Optional<ServerConnection> currentServer = player.getCurrentServer();
-                        if (currentServer.isPresent()) {
-                            possiblePlayers = getEligiblePlayers(currentServer.get().getServer());
-                        } else {
-                            possiblePlayers = getEligiblePlayers(proxyServer);
-                        }
-                    } else {
-                        possiblePlayers = getEligiblePlayers(proxyServer);
-                    }
-                    Collection<String> possibleValues = possiblePlayers.stream()
-                            .map(Player::getUsername)
-                            .toList();
-
-                    if (possibleValues.isEmpty())
-                        return Suggestions.empty();
-
-                    String remaining = builder.getRemaining().toLowerCase();
-                    possibleValues.stream()
-                            .filter(str -> str.toLowerCase().startsWith(remaining))
-                            .map(StringArgumentType::escapeIfRequired)
-                            .forEach(builder::suggest);
-                    return builder.buildFuture();
-                })
-                .executes(context -> {
-                    sendHelpMessage(context.getSource());
-                    return 1;
-                });
-
-        RequiredArgumentBuilder<CommandSource, String> yesNoNode = RequiredArgumentBuilder.
-                <CommandSource, String>argument("yesNo", StringArgumentType.string())
-                .suggests(((commandContext, suggestionsBuilder) -> {
-                    List<String> yesNoValues = Arrays.asList("yes", "no");
-                    String remaining = suggestionsBuilder.getRemaining().toLowerCase();
-                    yesNoValues.stream()
-                            .filter((String str) -> str.toLowerCase().startsWith(remaining))
-                            .map(StringArgumentType::escapeIfRequired)
-                            .forEach(suggestionsBuilder::suggest);
-                    return suggestionsBuilder.buildFuture();
-                }));
-
-        LiteralArgumentBuilder<CommandSource> pageNode = LiteralArgumentBuilder
-                .<CommandSource>literal("page")
-                .requires(commandSource -> commandSource.hasPermission("chat.vote-to-mute"))
-                .then(RequiredArgumentBuilder.<CommandSource, Integer>argument("page number", IntegerArgumentType.integer(1))
-                        .suggests(((commandContext, suggestionsBuilder) -> {
-                            if (!(commandContext.getSource() instanceof Player player)) {
-                                return suggestionsBuilder.buildFuture();
-                            }
-                            Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId());
-                            if (instance.isEmpty()) {
-                                return suggestionsBuilder.buildFuture();
-                            }
-                            VoteToMuteStarter voteToMuteStarter = instance.get();
-                            String remaining = suggestionsBuilder.getRemaining().toLowerCase();
-                            int totalPages = voteToMuteStarter.getTotalPages();
-                            IntStream.range(1, totalPages + 1)
-                                    .mapToObj(String::valueOf)
-                                    .filter((String str) -> str.toLowerCase().startsWith(remaining))
-                                    .map(StringArgumentType::escapeIfRequired)
-                                    .forEach(suggestionsBuilder::suggest);
-                            return suggestionsBuilder.buildFuture();
-                        }))
-                        .executes(commandContext -> {
-                            if (!(commandContext.getSource() instanceof Player player)) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Only players can use this command.</red>"));
-                                return 1;
-                            }
-                            Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId());
-                            if (instance.isEmpty()) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>You don't have an active vote to mute.</red>"));
-                                return 1;
-                            }
-                            int pageNumber = commandContext.getArgument("page number", Integer.class);
-                            instance.get().showPage(pageNumber);
-                            return 1;
-                        })
-                ).executes(commandContext -> {
-                    sendHelpMessage(commandContext.getSource());
-                    return 1;
-                });
-
-        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())
-                        .executes(commandContext -> {
-                            if (!(commandContext.getSource() instanceof Player player)) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Only players can use this command.</red>"));
-                                return 1;
-                            }
-                            Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId());
-                            if (instance.isEmpty()) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>You don't have an active vote to mute.</red>"));
-                                return 1;
-                            }
-                            String listOfPages = commandContext.getArgument("list of messages", String.class);
-                            if (!listOfPages.matches("([1-9][0-9]*, )*[1-9][0-9]*")) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Please make sure to format the command correctly.</red>"));
-                                return 1;
-                            }
-                            VoteToMuteStarter voteToMuteStarter = instance.get();
-
-                            List<Integer> collect = Arrays.stream(listOfPages.split(", "))
-                                    .map(Integer::parseInt)
-                                    .collect(Collectors.toList());
-                            Optional<Integer> max = collect.stream().max(Integer::compare);
-                            if (max.isEmpty()) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Some of your selected messages do not exist.</red>"));
-                                return 1;
-                            }
-                            int highestLogEntry = max.get();
-
-                            if (voteToMuteStarter.getTotalLogEntries() < highestLogEntry) {
-                                commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Some of your selected messages do not exist.</red>"));
-                                return 1;
-                            }
-
-                            Optional<ServerConnection> currentServer = player.getCurrentServer();
-                            if (currentServer.isEmpty()) {
-                                sendHelpMessage(commandContext.getSource());
-                                return 1;
-                            }
-
-                            Component chatLogs = voteToMuteStarter.getChatLogsAndClose(collect);
-                            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, player)
-                                    .start();
-                            return 1;
-                        })
-                ).executes(commandContext -> {
-                    sendHelpMessage(commandContext.getSource());
-                    return 1;
-                });
-
-        LiteralArgumentBuilder<CommandSource> voteNode = LiteralArgumentBuilder
-                .<CommandSource>literal("vote")
-                .then(playerNode
-                        .then(yesNoNode
-                                .executes(commandContext -> {
-                                    if (!(commandContext.getSource() instanceof Player player)) {
-                                        commandContext.getSource().sendMessage(Utility.parseMiniMessage(
-                                                "<red>Only players are allowed to vote</red>"));
-                                        return 1;
-                                    }
-                                    String playerName = commandContext.getArgument("player", String.class);
-                                    Optional<ActiveVoteToMute> optionalActiveVoteToMute = ActiveVoteToMute.getInstance(playerName);
-                                    if (optionalActiveVoteToMute.isEmpty()) {
-                                        commandContext.getSource().sendMessage(Utility.parseMiniMessage(
-                                                "<red>This player does not have an active vote to mute them.</red>"));
-                                        return 1;
-                                    }
-                                    ActiveVoteToMute activeVoteToMute = optionalActiveVoteToMute.get();
-
-                                    if (!activeVoteToMute.countLowerRanks()) {
-                                        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);
-                                    switch (vote.toLowerCase()) {
-                                        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)));
-                                    }
-                                    return 1;
-                                })).executes(context -> {
-                            sendHelpMessage(context.getSource());
-                            return 1;
-                        })).executes(context -> {
-                    sendHelpMessage(context.getSource());
-                    return 1;
-                });
-
-        LiteralCommandNode<CommandSource> command = LiteralArgumentBuilder
-                .<CommandSource>literal("votetomutehelper")
-                .requires(commandSource -> commandSource.hasPermission("chat.backup-vote-to-mute"))
-                .requires(commandSource -> commandSource instanceof Player)
-                .then(voteNode)
-                .then(pageNode)
-                .then(enterMessagesNode)
-                .executes(context -> {
-                    sendHelpMessage(context.getSource());
-                    return 1;
-                })
-                .build();
-
-        BrigadierCommand brigadierCommand = new BrigadierCommand(command);
-
-        CommandMeta.Builder metaBuilder = proxyServer.getCommandManager().metaBuilder(brigadierCommand);
-
-        CommandMeta meta = metaBuilder.build();
-
-        proxyServer.getCommandManager().register(meta, brigadierCommand);
-    }
-
-    private int getTotalEligiblePlayers(RegisteredServer server, boolean countLowerRanks) {
-        return (int) server.getPlayersConnected().stream()
-                .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
-                .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>"));
-    }
-
-    private List<Player> getEligiblePlayers(ProxyServer proxyServer) {
-        return proxyServer.getAllPlayers().stream()
-                .filter(player -> player.hasPermission("chat.affected-by-vote-to-mute"))
-                .collect(Collectors.toList());
-    }
-
-    private List<Player> getEligiblePlayers(RegisteredServer registeredServer) {
-        return registeredServer.getPlayersConnected().stream()
-                .filter(player -> player.hasPermission("chat.affected-by-vote-to-mute"))
-                .collect(Collectors.toList());
-
-    }
-
-}

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

@@ -1,238 +0,0 @@
-package com.alttd.velocitychat.commands.vote_to_mute;
-
-import com.alttd.chat.config.Config;
-import com.alttd.chat.util.ALogger;
-import com.alttd.chat.util.Utility;
-import com.alttd.proxydiscordlink.DiscordLink;
-import com.alttd.proxydiscordlink.lib.net.dv8tion.jda.api.EmbedBuilder;
-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 net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
-import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
-import org.jetbrains.annotations.NotNull;
-
-import java.awt.*;
-import java.time.Duration;
-import java.util.*;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-public class ActiveVoteToMute {
-
-    private static final HashMap<String, ActiveVoteToMute> instances = new HashMap<>();
-    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;
-    private final boolean countLowerRanks;
-    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))
-            return Optional.empty();
-        return Optional.of(instances.get(username));
-    }
-
-    public static void removePotentialVoter(Player player, RegisteredServer previousServer) {
-        if (!player.hasPermission("chat.backup-vote-to-mute"))
-            return;
-        if (player.hasPermission("chat.vote-to-mute")) {
-            instances.values().stream()
-                    .filter(activeVoteToMute -> previousServer == null || activeVoteToMute.getServer().getServerInfo().hashCode() == previousServer.getServerInfo().hashCode())
-                    .forEach(inst -> inst.removeEligibleVoter(player.getUniqueId()));
-        } else {
-            instances.values().stream()
-                    .filter(ActiveVoteToMute::countLowerRanks)
-                    .filter(activeVoteToMute -> previousServer == null || activeVoteToMute.getServer().getServerInfo().hashCode() == previousServer.getServerInfo().hashCode())
-                    .forEach(inst -> inst.removeEligibleVoter(player.getUniqueId()));
-        }
-    }
-
-    public static void addPotentialVoter(Player player, ServerConnection server) {
-        if (!player.hasPermission("chat.backup-vote-to-mute"))
-            return;
-        if (player.hasPermission("chat.vote-to-mute")) {
-            instances.values().stream()
-                    .filter(activeVoteToMute -> activeVoteToMute.getServer().getServerInfo().hashCode() == server.getServerInfo().hashCode())
-                    .forEach(activeVoteToMute -> activeVoteToMute.addEligibleVoter(player));
-        } else {
-            instances.values().stream()
-                    .filter(ActiveVoteToMute::countLowerRanks)
-                    .filter(activeVoteToMute -> activeVoteToMute.getServer().getServerInfo().hashCode() == server.getServerInfo().hashCode())
-                    .forEach(activeVoteToMute -> activeVoteToMute.addEligibleVoter(player));
-        }
-    }
-
-    public ActiveVoteToMute(@NotNull Player votedPlayer, @NotNull RegisteredServer server, ProxyServer proxyServer, Duration duration,
-                            int totalEligibleVoters, boolean countLowerRanks, Component chatLogs, @NotNull Player startedByPlayer) {
-        this.chatLogs = chatLogs;
-        this.votedPlayer = votedPlayer;
-        this.totalEligibleVoters = totalEligibleVoters;
-        this.countLowerRanks = countLowerRanks;
-        this.server = server;
-        this.proxyServer = proxyServer;
-        instances.put(votedPlayer.getUsername(), this);
-        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
-        executorService.schedule(this::endVote,
-                duration.toMinutes(), TimeUnit.MINUTES);
-        this.startedByPlayer = startedByPlayer;
-    }
-
-    private RegisteredServer getServer() {
-        return server;
-    }
-
-    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.</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"))
-                .forEach(player -> player.sendMessage(message));
-    }
-
-    public void start() {
-        Component message = getVoteStartMessage();
-        server.getPlayersConnected().stream()
-                .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
-                .forEach(player -> player.sendMessage(message));
-    }
-
-    public void vote(UUID uuid, boolean votedToMute) {
-        if (votedToMute) {
-            votedFor.add(uuid);
-            votedAgainst.remove(uuid);
-            if (!votePassed()) {
-                return;
-            }
-            endedVote = true;
-            instances.remove(votedPlayer.getUsername());
-            mutePlayer();
-        } else {
-            votedAgainst.add(uuid);
-            votedFor.remove(uuid);
-        }
-    }
-
-    public boolean votePassed() {
-        double totalVotes = (votedFor.size() + votedAgainst.size());
-        if (totalVotes == 0 || votedFor.isEmpty()) {
-            return false;
-        }
-        if (totalVotes / totalEligibleVoters < 0.6) {
-            return false;
-        }
-        return votedFor.size() / totalVotes > 0.6;
-    }
-
-    public boolean countLowerRanks() {
-        return countLowerRanks;
-    }
-
-    private void mutePlayer() {
-        Component message = Utility.parseMiniMessage("<prefix> <green>The vote to mute <player> has passed, they will be muted.</green>",
-                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"))
-                .forEach(player -> player.sendMessage(message));
-        proxyServer.getCommandManager().executeAsync(proxyServer.getConsoleCommandSource(),
-                String.format("tempmute %s 1h Muted by the community - under review. -p", votedPlayer.getUsername()));
-
-
-        String chatLogsString = PlainTextComponentSerializer.plainText().serialize(chatLogs);
-        EmbedBuilder embedBuilder = buildMutedEmbed(chatLogsString);
-
-        ALogger.info(String.format("Player %s muted by vote\nLogs:\n%s\n\nVotes for:\n%s\nVotes against:\n%s\n",
-                votedPlayer.getUsername(),
-                chatLogsString,
-                parseUUIDsToPlayerOrString(votedFor),
-                parseUUIDsToPlayerOrString(votedAgainst)
-                ));
-
-        long id = Config.serverChannelId.get("general");
-        DiscordLink.getPlugin().getBot().sendEmbedToDiscord(id, embedBuilder, -1);
-    }
-
-    @NotNull
-    private EmbedBuilder buildMutedEmbed(String chatLogsString) {
-        EmbedBuilder embedBuilder = new EmbedBuilder();
-        embedBuilder.setAuthor(votedPlayer.getUsername(), null, "https://crafatar.com/avatars/" + votedPlayer.getUniqueId() + "?overlay");
-        embedBuilder.setTitle("Player muted by vote");
-        embedBuilder.setColor(Color.CYAN);
-        embedBuilder.addField("Logs",
-                chatLogsString.substring(0, Math.min(chatLogsString.length(), 1024)),
-                false);
-        embedBuilder.addField("Server",
-                server.getServerInfo().getName().substring(0, 1).toUpperCase() + server.getServerInfo().getName().substring(1),
-                true);
-        embedBuilder.addField("Started by",
-                String.format("Username: %s\nUUID: %s", startedByPlayer.getUsername(), startedByPlayer.getUniqueId().toString()),
-                true);
-        return embedBuilder;
-    }
-
-    private String parseUUIDsToPlayerOrString(Collection<UUID> uuids) {
-        return uuids.stream().map(uuid -> {
-            Optional<Player> player = proxyServer.getPlayer(uuid);
-            if (player.isPresent()) {
-                return player.get().getUsername();
-            }
-            return uuid.toString();
-        }).collect(Collectors.joining("\n"));
-    }
-
-    public void addEligibleVoter(Player player) {
-        UUID uuid = player.getUniqueId();
-        if (votedAgainst.contains(uuid) || votedFor.contains(uuid))
-            return;
-        totalEligibleVoters++;
-        player.sendMessage(getVoteStartMessage());
-    }
-
-    public void removeEligibleVoter(UUID uuid) {
-        if (votedFor.contains(uuid) || votedAgainst.contains(uuid))
-            return;
-        totalEligibleVoters--;
-    }
-
-    private Component getVoteStartMessage() {
-        return Utility.parseMiniMessage(
-                String.format("""
-                        <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()),
-                Placeholder.component("prefix", prefix),
-                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

@@ -1,129 +0,0 @@
-package com.alttd.velocitychat.commands.vote_to_mute;
-
-import com.alttd.chat.objects.chat_log.ChatLog;
-import com.alttd.chat.objects.chat_log.ChatLogHandler;
-import com.alttd.chat.util.Utility;
-import com.velocitypowered.api.proxy.Player;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.JoinConfiguration;
-import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
-import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
-
-import java.time.Duration;
-import java.util.*;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-public class VoteToMuteStarter {
-
-    private static final HashMap<UUID, VoteToMuteStarter> instanceMap = new HashMap<>();
-
-    private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>");
-    private final ChatLogHandler chatLogHandler;
-    private final Player votedPlayer;
-    private final Player commandSource;
-    private final String serverName;
-    private List<Component> parsedChatLogs;
-    private final boolean countLowerRanks;
-
-    public static Optional<VoteToMuteStarter> getInstance(UUID uuid) {
-        if (!instanceMap.containsKey(uuid))
-            return Optional.empty();
-        return Optional.of(instanceMap.get(uuid));
-    }
-
-    public VoteToMuteStarter(ChatLogHandler chatLogHandler, Player votedPlayer, Player commandSource, String serverName, boolean countLowerRanks) {
-        this.chatLogHandler = chatLogHandler;
-        this.votedPlayer = votedPlayer;
-        this.commandSource = commandSource;
-        this.serverName = serverName;
-        this.countLowerRanks = countLowerRanks;
-        instanceMap.put(commandSource.getUniqueId(), this);
-    }
-
-    public void start() {
-        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),
-                        Placeholder.parsed("player", votedPlayer.getUsername())));
-                return;
-            }
-            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>", Placeholder.component("prefix", prefix)));
-            showPage(1);
-        });
-    }
-
-    private void parseChatLogs(List<ChatLog> chatLogs) {
-        TagResolver.Single playerTag = Placeholder.parsed("player", votedPlayer.getUsername());
-        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>. <prefix> <player>: <message>",
-                        TagResolver.resolver(
-                                Placeholder.unparsed("message", chatLogs.get(i).getMessage()),
-                                Placeholder.parsed("number", String.valueOf(i + 1)),
-                                playerTag, prefixTag
-                        ))
-                )
-                .toList();
-    }
-
-    public void showPage(int page) {
-        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 > 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:/votetomutehelper page ")
-                    .append(page + 1)
-                    .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()),
-                Placeholder.component("prefix", prefix),
-                Placeholder.component("logs", chatLogsComponent)));
-    }
-
-    /**
-     * Retrieves the chat logs for the given list of IDs. It removes 1 from the IDs before using them
-     * It removes the instance from the hashmap after this function call
-     *
-     * @param ids A list of integers representing the IDs of the chat logs to retrieve.
-     * @return A Component object containing the selected chat logs joined by newlines.
-     */
-    public Component getChatLogsAndClose(List<Integer> ids) {
-        List<Component> selectedChatLogs = ids.stream()
-                .filter(id -> id >= 1 && id <= parsedChatLogs.size())
-                .map(id -> parsedChatLogs.get(id - 1))
-                .collect(Collectors.toList());
-
-        instanceMap.remove(commandSource.getUniqueId());
-        return Component.join(JoinConfiguration.newlines(), selectedChatLogs);
-    }
-
-    public int getTotalPages() {
-        return (int) Math.ceil((double) parsedChatLogs.size() / 10);
-    }
-
-    public Player getVotedPlayer() {
-        return votedPlayer;
-    }
-
-    public int getTotalLogEntries() {
-        return parsedChatLogs.size();
-    }
-
-    public boolean countLowerRanks() {
-        return countLowerRanks;
-    }
-}

velocity/src/main/java/com/alttd/velocitychat/listeners/ProxyPlayerListener.java

@@ -6,7 +6,6 @@ import com.alttd.chat.objects.Mail;
 import com.alttd.chat.util.Utility;
 import com.alttd.velocitychat.VelocityChat;
 import com.alttd.chat.config.Config;
-import com.alttd.velocitychat.commands.vote_to_mute.ActiveVoteToMute;
 import com.alttd.velocitychat.data.ServerWrapper;
 import com.alttd.velocitychat.handlers.ServerHandler;
 import com.alttd.chat.managers.PartyManager;
@@ -18,7 +17,6 @@ import com.velocitypowered.api.event.connection.LoginEvent;
 import com.velocitypowered.api.event.player.ServerConnectedEvent;
 import com.velocitypowered.api.event.player.ServerPostConnectEvent;
 import com.velocitypowered.api.proxy.Player;
-import com.velocitypowered.api.proxy.ServerConnection;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
@@ -50,20 +48,9 @@ public class ProxyPlayerListener {
 
     @Subscribe(order = PostOrder.LAST)
     public void afterPlayerLogin(ServerPostConnectEvent event) {
+        if (event.getPreviousServer() != null)
+            return;
         Player player = event.getPlayer();
-        RegisteredServer previousServer = event.getPreviousServer();
-        if (previousServer != null) {
-            ActiveVoteToMute.removePotentialVoter(player, previousServer);
-            Optional<ServerConnection> currentServer = player.getCurrentServer();
-            if (currentServer.isEmpty())
-                return;
-            ActiveVoteToMute.addPotentialVoter(player, currentServer.get());
-            return;
-        }
-        Optional<ServerConnection> currentServer = player.getCurrentServer();
-        if (currentServer.isEmpty())
-            return;
-        ActiveVoteToMute.addPotentialVoter(player, currentServer.get());
         ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId());
         List<Mail> unReadMail = chatUser.getUnReadMail();
         if (unReadMail.isEmpty())
@@ -75,7 +62,6 @@ public class ProxyPlayerListener {
 
     @Subscribe
     public void quitEvent(DisconnectEvent event) {
-        ActiveVoteToMute.removePotentialVoter(event.getPlayer(), null);
         UUID uuid = event.getPlayer().getUniqueId();
         Party party = PartyManager.getParty(event.getPlayer().getUniqueId());
         if (party == null) return;