Altitude/Chat
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Altitude:main
Branches Tags
Altitude:main
Altitude:ignore_fix
Altitude:april_fools
Altitude:dev/requests
Altitude:4.9
..
compare: Altitude:dev/requests
Branches Tags
Altitude:main
Altitude:ignore_fix
Altitude:april_fools
Altitude:dev/requests
Altitude:4.9

2 Commits
main ... dev/reques

Author SHA1 Message Date
Len 94484593f1 progress on requests 2024-01-13 19:14:57 +01:00
Len de04c6b80a Nick and Prefix requests 2024-01-04 17:11:00 +01:00
78 changed files with 1288 additions and 2515 deletions
Show Stats Expand all files Collapse all files

23
Jenkinsfile vendored
View File

@ -1,23 +0,0 @@
pipeline {
agent any
environment {
NEXUS_CREDS = credentials('alttd-snapshot-user')
}
stages {
stage('Gradle') {
steps {
sh './gradlew build -PalttdSnapshotUsername=$NEXUS_CREDS_USR -PalttdSnapshotPassword=$NEXUS_CREDS_PSW'
}
}
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
}
}
}
}

9
api/build.gradle.kts
View File

@ -3,12 +3,11 @@ plugins {
}
dependencies {
// Cosmos
compileOnly("com.alttd.cosmos:cosmos-api:1.21.8-R0.1-SNAPSHOT") {
isChanging = true
compileOnly("com.alttd:Galaxy-API:1.19.2-R0.1-SNAPSHOT") {
// exclude("net.kyori")
}
compileOnly("org.spongepowered:configurate-yaml:4.2.0") // Configurate
compileOnly("net.luckperms:api:5.5") // Luckperms
compileOnly("org.spongepowered:configurate-yaml:4.1.2") // Configurate
compileOnly("net.luckperms:api:5.3") // Luckperms
}
publishing {

4
api/src/main/java/com/alttd/chat/ChatAPI.java
View File

@ -15,9 +15,9 @@ public abstract interface ChatAPI {
DatabaseConnection getDataBase();
void reloadConfig();
void ReloadConfig();
void reloadChatFilters();
void ReloadChatFilters();
HashMap<String, String> getPrefixes();

9
api/src/main/java/com/alttd/chat/ChatImplementation.java
View File

@ -5,12 +5,15 @@ import com.alttd.chat.config.PrefixConfig;
import com.alttd.chat.database.DatabaseConnection;
import com.alttd.chat.database.Queries;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.util.ALogger;
import net.luckperms.api.LuckPerms;
import net.luckperms.api.LuckPermsProvider;
import net.luckperms.api.model.group.Group;
import java.util.HashMap;
import java.util.Map;
public class ChatImplementation implements ChatAPI{
@ -23,7 +26,7 @@ public class ChatImplementation implements ChatAPI{
public ChatImplementation() {
instance = this;
reloadConfig();
ReloadConfig();
luckPerms = getLuckPerms();
databaseConnection = getDataBase();
@ -54,13 +57,13 @@ public class ChatImplementation implements ChatAPI{
}
@Override
public void reloadConfig() {
public void ReloadConfig() {
Config.init();
loadPrefixes();
}
@Override
public void reloadChatFilters() {
public void ReloadChatFilters() {
RegexManager.initialize();
}

222
api/src/main/java/com/alttd/chat/config/Config.java
View File

@ -1,11 +1,10 @@
package com.alttd.chat.config;
import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.Utility;
import com.google.common.collect.Lists;
import io.leangen.geantyref.TypeToken;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import org.spongepowered.configurate.ConfigurationNode;
import org.spongepowered.configurate.ConfigurationOptions;
import org.spongepowered.configurate.serialize.SerializationException;
@ -20,7 +19,6 @@ import java.lang.reflect.Modifier;
import java.util.*;
import java.util.regex.Pattern;
@SuppressWarnings("unused")
public final class Config {
private static final Pattern PATH_PATTERN = Pattern.compile("\\.");
private static final String HEADER = "";
@ -33,9 +31,8 @@ public final class Config {
static boolean verbose;
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)
@ -52,14 +49,14 @@ public final class Config {
return;
}
} catch (IOException error) {
ALogger.error(error.getMessage(), error);
error.printStackTrace();
}
}
try {
config = configLoader.load(ConfigurationOptions.defaults().header(HEADER).shouldCopyDefaults(false));
} catch (IOException e) {
ALogger.error(e.getMessage(), e);
e.printStackTrace();
}
verbose = getBoolean("verbose", true);
@ -69,7 +66,7 @@ public final class Config {
try {
configLoader.save(config);
} catch (IOException e) {
ALogger.error(e.getMessage(), e);
e.printStackTrace();
}
}
@ -81,7 +78,7 @@ public final class Config {
method.setAccessible(true);
method.invoke(instance);
} catch (InvocationTargetException | IllegalAccessException ex) {
ALogger.error(ex.getMessage(), ex);
ex.printStackTrace();
}
}
}
@ -89,7 +86,7 @@ public final class Config {
try {
configLoader.save(config);
} catch (IOException ex) {
ALogger.error(ex.getMessage(), ex);
ex.printStackTrace();
}
}
@ -97,7 +94,7 @@ public final class Config {
try {
configLoader.save(config);
} catch (IOException ex) {
ALogger.error(ex.getMessage(), ex);
ex.printStackTrace();
}
}
@ -110,18 +107,17 @@ public final class Config {
try {
config.node(splitPath(path)).set(def);
} catch (SerializationException e) {
ALogger.error(e.getMessage(), e);
e.printStackTrace();
}
}
}
private static void setString(String path, String def) {
try {
if (config.node(splitPath(path)).virtual()) {
if(config.node(splitPath(path)).virtual())
config.node(splitPath(path)).set(io.leangen.geantyref.TypeToken.get(String.class), def);
}
} catch(SerializationException ex) {
ALogger.error(ex.getMessage(), ex);
ex.printStackTrace();
}
}
@ -155,7 +151,7 @@ public final class Config {
set(path, def);
return config.node(splitPath(path)).getList(TypeToken.get(String.class));
} catch(SerializationException ex) {
ALogger.error(ex.getMessage(), ex);
ex.printStackTrace();
}
return new ArrayList<>();
}
@ -168,9 +164,7 @@ public final class Config {
return config.node(splitPath(path));
}
/**
* ONLY EDIT ANYTHING BELOW THIS LINE
**/
/** ONLY EDIT ANYTHING BELOW THIS LINE **/
public static List<String> PREFIXGROUPS = new ArrayList<>();
public static List<String> CONFLICTINGPREFIXGROUPS = new ArrayList<>();
public static List<String> STAFFGROUPS = new ArrayList<>();
@ -179,11 +173,9 @@ public final class Config {
public static UUID CONSOLEUUID = UUID.randomUUID();
public static int EMOTELIMIT = 3;
public static String MENTIONPLAYERTAG = "<aqua>@</aqua>";
private static void settings() {
PREFIXGROUPS = getList("settings.prefix-groups",
Lists.newArrayList("discord", "socialmedia", "eventteam", "eventleader", "youtube", "twitch",
"developer"));
Lists.newArrayList("discord", "socialmedia", "eventteam", "eventleader", "youtube", "twitch", "developer"));
CONFLICTINGPREFIXGROUPS = getList("settings.prefix-conflicts-groups",
Lists.newArrayList("eventteam", "eventleader"));
STAFFGROUPS = getList("settings.staff-groups",
@ -197,13 +189,10 @@ public final class Config {
public static List<String> MESSAGECOMMANDALIASES = new ArrayList<>();
public static List<String> REPLYCOMMANDALIASES = new ArrayList<>();
public static String MESSAGESENDER =
"<hover:show_text:Click to reply><click:suggest_command:/msg <receivername> ><light_purple>(Me -> <gray><receiver></gray>)</hover> <message>";
public static String MESSAGERECIEVER =
"<hover:show_text:Click to reply><click:suggest_command:/msg <sendername> ><light_purple>(<gray><sender></gray> on <server> -> Me)</hover> <message>";
public static String MESSAGESENDER = "<hover:show_text:Click to reply><click:suggest_command:/msg <receivername> ><light_purple>(Me -> <gray><receiver></gray>)</hover> <message>";
public static String MESSAGERECIEVER = "<hover:show_text:Click to reply><click:suggest_command:/msg <sendername> ><light_purple>(<gray><sender></gray> on <server> -> Me)</hover> <message>";
public static String MESSAGESPY = "<gray>(<gray><sendername></gray> -> <receivername>) <message>";
public static String RECEIVER_DOES_NOT_EXIST = "<red><player> is not a valid player.</red>";
private static void messageCommand() {
MESSAGECOMMANDALIASES.clear();
REPLYCOMMANDALIASES.clear();
@ -215,14 +204,12 @@ public final class Config {
RECEIVER_DOES_NOT_EXIST = getString("commands.message.receiver-does-not-exist", RECEIVER_DOES_NOT_EXIST);
}
public static String GCFORMAT =
"<white><light_purple><prefix></light_purple> <gray><sender></gray> <hover:show_text:on <server>><yellow>to Global</yellow></hover><gray>: <message>";
public static String GCFORMAT = "<white><light_purple><prefix></light_purple> <gray><sender></gray> <hover:show_text:on <server>><yellow>to Global</yellow></hover><gray>: <message>";
public static String GCPERMISSION = "proxy.globalchat";
public static List<String> GCALIAS = new ArrayList<>();
public static String GCNOTENABLED = "You don't have global chat enabled.";
public static String GCONCOOLDOWN = "You have to wait <cooldown> seconds before using this feature again.";
public static int GCCOOLDOWN = 30;
private static void globalChat() {
GCFORMAT = getString("commands.globalchat.format", GCFORMAT);
GCPERMISSION = getString("commands.globalchat.view-chat-permission", GCPERMISSION);
@ -232,32 +219,26 @@ public final class Config {
GCCOOLDOWN = getInt("commands.globalchat.cooldown", GCCOOLDOWN);
}
public static String CHATFORMAT =
"<white><light_purple><prefixall> <gray><hover:show_text:Click to message <sendername>><click:suggest_command:/msg <sendername> ><sender></hover>: <white><message>";
public static String CHATFORMAT = "<white><light_purple><prefixall> <gray><hover:show_text:Click to message <sendername>><click:suggest_command:/msg <sendername> ><sender></hover>: <white><message>";
public static String URLFORMAT = "<click:OPEN_URL:<clickurl>><url></click>";
private static void Chat() {
CHATFORMAT = getString("chat.format", CHATFORMAT);
URLFORMAT = getString("chat.urlformat", URLFORMAT);
}
public static List<String> GACECOMMANDALIASES = new ArrayList<>();
public static String GACFORMAT =
"<hover:show_text:Click to reply><click:suggest_command:/acg ><yellow>(<sender> on <server> -> Team)</hover> <message>";
public static String GACFORMAT = "<hover:show_text:Click to reply><click:suggest_command:/acg ><yellow>(<sender> on <server> -> Team)</hover> <message>";
private static void globalAdminChat() {
GACECOMMANDALIASES = getList("commands.globaladminchat.aliases", Lists.newArrayList("acg"));
GACFORMAT = getString("commands.globaladminchat.format", GACFORMAT);
}
public static String MESSAGECHANNEL = "altitude:chatplugin";
private static void messageChannels() {
MESSAGECHANNEL = getString("settings.message-channel", MESSAGECHANNEL);
}
public static ConfigurationNode REGEXNODE = null;
private static void RegexNOde() {
REGEXNODE = getNode("regex-settings");
}
@ -266,7 +247,6 @@ public final class Config {
public static String SERVERSWTICHMESSAGETO = "<gray>* <player> leaves to <to_server>...";
public static String SERVERJOINMESSAGE = "<green>* <player> appears from thin air...";
public static String SERVERLEAVEMESSAGE = "<red>* <player> vanishes in the mist...";
private static void JoinLeaveMessages() {
SERVERSWTICHMESSAGEFROM = getString("messages.switch-server-from", SERVERSWTICHMESSAGEFROM);
SERVERSWTICHMESSAGETO = getString("messages.switch-server-to", SERVERSWTICHMESSAGETO);
@ -275,10 +255,8 @@ public final class Config {
}
public static String PARTY_FORMAT =
"<dark_aqua>(<gray><sender></gray><hover:show_text:\"on <server>\"> → <party></hover>) <message>";
public static String PARTY_SPY =
"<i><gray>PC:</gray><dark_gray> <dark_gray><username></dark_gray>: <dark_gray><party></dark_gray> <message></dark_gray></i>";
public static String PARTY_FORMAT = "<dark_aqua>(<gray><sender></gray><hover:show_text:\"on <server>\"> → <party></hover>) <message>";
public static String PARTY_SPY = "<i><gray>PC:</gray><dark_gray> <dark_gray><username></dark_gray>: <dark_gray><party></dark_gray> <message></dark_gray></i>";
public static String NO_PERMISSION = "<red>You don't have permission to use this command.</red>";
public static String NO_CONSOLE = "<red>This command can not be used by console</red>";
public static String CREATED_PARTY = "<green>You created a chat party called: " +
@ -292,11 +270,9 @@ public final class Config {
public static String INVALID_PASSWORD = "<red>Invalid password.</red>";
public static String JOINED_PARTY = "<green>You joined <party_name>!</green>";
public static String PLAYER_JOINED_PARTY = "<green><player_name> joined <party_name>!</green>";
public static String NOTIFY_FINDING_NEW_OWNER =
"<dark_aqua>Since you own this chat party a new party owner will be chosen.<dark_aqua>";
public static String NOTIFY_FINDING_NEW_OWNER = "<dark_aqua>Since you own this chat party a new party owner will be chosen.<dark_aqua>";
public static String LEFT_PARTY = "<green>You have left the chat party!</green>";
public static String OWNER_LEFT_PARTY =
"<dark_aqua>[ChatParty]: <old_owner> left the chat party, the new party owner is <new_owner></dark_aqua>";
public static String OWNER_LEFT_PARTY = "<dark_aqua>[ChatParty]: <old_owner> left the chat party, the new party owner is <new_owner></dark_aqua>";
public static String PLAYER_LEFT_PARTY = "<dark_aqua>[ChatParty]: <player_name> left the chat party!</dark_aqua>";
public static String NEW_PARTY_OWNER = "<dark_aqua>[ChatParty]: <old_owner> transferred the party to <new_owner>!";
public static String CANT_REMOVE_PARTY_OWNER = "<red>You can't remove yourself, please leave instead.</red>";
@ -310,23 +286,20 @@ public final class Config {
"<dark_aqua>You received an invite to join <party>, click this message to accept.</dark_aqua></click>";
public static String PARTY_MEMBER_LOGGED_ON = "<dark_aqua>[ChatParty] <player> joined Altitude...</dark_aqua>";
public static String PARTY_MEMBER_LOGGED_OFF = "<dark_aqua>[ChatParty] <player> left Altitude...</dark_aqua>";
public static String RENAMED_PARTY =
"<dark_aqua>[ChatParty] <owner> changed the party name from <old_name> to <new_name>!</dark_aqua>";
public static String RENAMED_PARTY = "<dark_aqua>[ChatParty] <owner> changed the party name from <old_name> to <new_name>!</dark_aqua>";
public static String CHANGED_PASSWORD = "<green>Password was set to <password></green>";
public static String DISBAND_PARTY_CONFIRM = "<green><bold>Are you sure you want to disband your party?</bold> " +
"Type <gold>/party disband confirm <party></gold> to confirm.";
public static String DISBANDED_PARTY =
"<dark_aqua>[ChatParty] <owner> has disbanded <party>, everyone has been removed.</dark_aqua>";
public static String DISBANDED_PARTY = "<dark_aqua>[ChatParty] <owner> has disbanded <party>, everyone has been removed.</dark_aqua>";
public static String PARTY_INFO = """
<gold><bold>Chat party info</bold>:
</gold><green>Name: <dark_aqua><party></dark_aqua>
Password: <dark_aqua><password></dark_aqua>
Owner: <owner>
Members: <members>""";
public static ComponentLike ONLINE_PREFIX = null;
public static ComponentLike OFFLINE_PREFIX = null;
public static Component ONLINE_PREFIX = null;
public static Component OFFLINE_PREFIX = null;
public static String PARTY_TOGGLED = "<dark_aqua>Party chat toggled <status>.</dark_aqua>";
private static void party() {
PARTY_FORMAT = getString("party.format", PARTY_FORMAT);
PARTY_SPY = getString("party.spy", PARTY_SPY);
@ -365,27 +338,17 @@ public final class Config {
public static String PARTY_HELP_WRAPPER = "<gold>ChatParty help:\n<commands></gold>";
public static String PARTY_HELP_HELP = "<green>Show this menu: <gold>/party help</gold></green>";
public static String PARTY_HELP_CREATE =
"<green>Create a party: <gold>/party create <party_name> <party_password></gold></green>";
public static String PARTY_HELP_INFO =
"<green>Show info about your current party: <gold>/party info</gold></green>";
public static String PARTY_HELP_INVITE =
"<green>Invite a user to your party: <gold>/party invite <username></gold></green>";
public static String PARTY_HELP_JOIN =
"<green>Join a party: <gold>/party join <party_name> <party_password></gold></green>";
public static String PARTY_HELP_CREATE = "<green>Create a party: <gold>/party create <party_name> <party_password></gold></green>";
public static String PARTY_HELP_INFO = "<green>Show info about your current party: <gold>/party info</gold></green>";
public static String PARTY_HELP_INVITE = "<green>Invite a user to your party: <gold>/party invite <username></gold></green>";
public static String PARTY_HELP_JOIN = "<green>Join a party: <gold>/party join <party_name> <party_password></gold></green>";
public static String PARTY_HELP_LEAVE = "<green>Leave your current party: <gold>/party leave</gold></green>";
public static String PARTY_HELP_NAME =
"<green>Change the name of your party: <gold>/party name <new_name></gold></green>";
public static String PARTY_HELP_OWNER =
"<green>Change the owner of your party: <gold>/party owner <new_owner_name></gold></green>";
public static String PARTY_HELP_PASSWORD =
"<green>Change the password of your party: <gold>/party password <new_password></gold></green>";
public static String PARTY_HELP_REMOVE =
"<green>Remove a member from your party: <gold>/party remove <member_name></gold></green>";
public static String PARTY_HELP_DISBAND =
"<green>Remove everyone from your party and disband it: <gold>/party disband</gold></green>";
public static String PARTY_HELP_NAME = "<green>Change the name of your party: <gold>/party name <new_name></gold></green>";
public static String PARTY_HELP_OWNER = "<green>Change the owner of your party: <gold>/party owner <new_owner_name></gold></green>";
public static String PARTY_HELP_PASSWORD = "<green>Change the password of your party: <gold>/party password <new_password></gold></green>";
public static String PARTY_HELP_REMOVE = "<green>Remove a member from your party: <gold>/party remove <member_name></gold></green>";
public static String PARTY_HELP_DISBAND = "<green>Remove everyone from your party and disband it: <gold>/party disband</gold></green>";
public static String PARTY_HELP_CHAT = "<green>Talk in party chat: <gold>/p <message></gold></green>";
private static void partyHelp() {
PARTY_HELP_WRAPPER = getString("party.help.wrapper", PARTY_HELP_WRAPPER);
PARTY_HELP_HELP = getString("party.help.help", PARTY_HELP_HELP);
@ -403,17 +366,12 @@ public final class Config {
}
public static String CUSTOM_CHANNEL_TOGGLED = "<yellow>Toggled <channel> <status>.</yellow>";
public static ComponentLike TOGGLED_ON = null;
public static ComponentLike TOGGLED_OFF = null;
public static double LOCAL_DISTANCE;
public static String CHANNEL_SPY =
"<i><gray>SPY:</gray> <dark_gray>(<dark_gray><sender> → <channel>) <message></dark_gray>";
public static Component TOGGLED_ON = null;
public static Component TOGGLED_OFF = null;
private static void chatChannels() {
ConfigurationNode node = getNode("chat-channels");
if (node.empty()) {
getString("chat-channels.ac.format",
"<white><gray><sender></gray> <hover:show_text:on <server>><yellow>to <channel></yellow></hover><gray>: <message>");
getString("chat-channels.ac.format", "<white><gray><sender></gray> <hover:show_text:on <server>><yellow>to <channel></yellow></hover><gray>: <message>");
getList("chat-channels.ac.servers", List.of("lobby"));
getBoolean("chat-channels.ac.proxy", false);
node = getNode("chat-channels");
@ -425,23 +383,16 @@ public final class Config {
new CustomChannel(channelName,
getString(key + "format", ""),
getList(key + "servers", Collections.EMPTY_LIST),
getList(key + "alias", Collections.EMPTY_LIST),
getBoolean(key + "proxy", false),
getBoolean(key + "local", false)
);
getBoolean(key + "proxy", false));
}
CUSTOM_CHANNEL_TOGGLED = getString("chat-channels-messages.channel-toggled", CUSTOM_CHANNEL_TOGGLED);
TOGGLED_ON =
Utility.parseMiniMessage(getString("chat-channels-messages.channel-on", "<green>on</green><gray>"));
TOGGLED_ON = Utility.parseMiniMessage(getString("chat-channels-messages.channel-on", "<green>on</green><gray>"));
TOGGLED_OFF = Utility.parseMiniMessage(getString("chat-channels-messages.channel-off", "<red>off</red><gray>"));
LOCAL_DISTANCE = getDouble("chat-channels-messages.local-distance", 200.0);
CHANNEL_SPY = getString("chat-channels-messages.spy", CHANNEL_SPY);
}
public static String SERVERMUTEPERMISSION = "chat.command.mute-server";
public static String SPYPERMISSION = "chat.socialspy";
private static void permissions() {
SERVERMUTEPERMISSION = getString("permissions.server-mute", SERVERMUTEPERMISSION);
SPYPERMISSION = getString("permissions.spy-permission", SPYPERMISSION);
@ -452,7 +403,6 @@ public final class Config {
public static String DATABASE = "database";
public static String USERNAME = "root";
public static String PASSWORD = "root";
private static void database() {
IP = getString("database.ip", IP);
PORT = getString("database.port", PORT);
@ -462,25 +412,18 @@ public final class Config {
}
public static String NOTIFICATIONFORMAT = "<red>[<prefix>] <displayname> <target> <input>";
private static void notificationSettings() {
NOTIFICATIONFORMAT = getString("settings.blockedmessage-notification", NOTIFICATIONFORMAT);
}
public static String mailHeader = "===== List Mails ====='";
public static String mailBody =
"<white>From:</white> [<staffprefix>] <sender> <white><hover:show_text:'<date>'><time_ago> day(s) ago</hover>: </white><message>";
public static String mailBody = "<white>From:</white> [<staffprefix>] <sender> <white><hover:show_text:'<date>'><time_ago> day(s) ago</hover>: </white><message>";
public static String mailFooter = "======================";
public static String mailNoUser = "<red>A player with this name hasn't logged in recently.";
public static String mailReceived =
"<yellow><click:run_command:/mail list unread>New mail from <sender>, click to view</click></yellow>";
public static String mailUnread =
"<green><click:run_command:/mail list unread>You have <amount> unread mail, click to view it.</click></green>";
public static String mailSent =
"<green>Successfully send mail to <player_name></green>: <#2e8b57><message></#2e8b57>";
public static String mailReceived = "<yellow><click:run_command:/mail list unread>New mail from <sender>, click to view</click></yellow>";
public static String mailUnread = "<green><click:run_command:/mail list unread>You have <amount> unread mail, click to view it.</click></green>";
public static String mailSent = "<green>Successfully send mail to <player_name></green>: <#2e8b57><message></#2e8b57>";
public static List<String> mailCommandAlias = new ArrayList<>();
public static int mailDisplayDelay = 5;
private static void mailSettings() {
mailHeader = getString("settings.mail.header", mailHeader);
mailBody = getString("settings.mail.message", mailBody);
@ -489,15 +432,11 @@ public final class Config {
mailReceived = getString("settings.mail.mail-received", mailReceived);
mailUnread = getString("settings.mail.mail-unread", mailUnread);
mailSent = getString("settings.mail.mail-sent", mailSent);
mailDisplayDelay = getInt("settings.mail.delay", mailDisplayDelay);
}
public static HashMap<String, Long> serverChannelId = new HashMap<>();
public static String REPORT_SENT =
"<green>Your report was sent, staff will contact you asap to help resolve your issue!</green>";
public static String REPORT_TOO_SHORT =
"<red>Please ensure your report is descriptive. We require at least 3 words per report</red>";
public static String REPORT_SENT = "<green>Your report was sent, staff will contact you asap to help resolve your issue!</green>";
public static String REPORT_TOO_SHORT = "<red>Please ensure your report is descriptive. We require at least 3 words per report</red>";
private static void loadChannelIds() {
serverChannelId.clear();
serverChannelId.put("general", getLong("discord-channel-id.general", (long) -1));
@ -505,9 +444,8 @@ public final class Config {
Map<Object, ? extends ConfigurationNode> objectMap = node.childrenMap();
for (Object o : objectMap.keySet()) {
String key = (String) o;
if (key.equalsIgnoreCase("general")) {
if (key.equalsIgnoreCase("general"))
continue;
}
ConfigurationNode configurationNode = objectMap.get(o);
long channelId = configurationNode.getLong();
serverChannelId.put(key.toLowerCase(), channelId);
@ -531,9 +469,7 @@ public final class Config {
}
public static String HELP_REPORT = "<red>/report <message></red>";
public static String FIRST_JOIN =
"<green>* Welcome <light_purple><player></light_purple> to Altitude! They've joined for the first time.</green>";
public static String FIRST_JOIN = "<green>* Welcome <light_purple><player></light_purple> to Altitude! They've joined for the first time.</green>";
private static void loadMessages() {
HELP_REPORT = getString("settings.mail.mail-sent", HELP_REPORT);
FIRST_JOIN = getString("settings.first-join.message", FIRST_JOIN);
@ -541,9 +477,7 @@ public final class Config {
public static String EMOTELIST_HEADER = "<bold>Available Chat Emotes</bold><newline>";
public static String EMOTELIST_ITEM = "<insert:\"<regex>\"><gold><regex></gold> : <emote></insert><newline>";
public static String EMOTELIST_FOOTER =
"<green>----<< <gray>Prev</gray> <page> <gray>/</gray> <pages> <gray>Next</gray> >>----";
public static String EMOTELIST_FOOTER = "<green>----<< <gray>Prev</gray> <page> <gray>/</gray> <pages> <gray>Next</gray> >>----";
private static void emoteListCommand() {
EMOTELIST_HEADER = getString("commands.emotelist.header", EMOTELIST_HEADER);
EMOTELIST_ITEM = getString("commands.emotelist.item", EMOTELIST_ITEM);
@ -554,42 +488,31 @@ public final class Config {
public static String NICK_CHANGED = "<yellow>Your nickname was changed to <nickname><yellow>.";
public static String NICK_NOT_CHANGED = "<yellow>Your nickname request was denied.";
public static String NICK_RESET = "<yellow>Nickname changed back to normal.";
public static String NICK_CHANGED_OTHERS =
"<gold><targetplayer><yellow>'s nickname was changed to <nickname><yellow>.";
public static String NICK_TARGET_NICK_CHANGE =
"<yellow>Your nickname was changed to <nickname> <yellow>by <sendernick><yellow>";
public static String NICK_CHANGED_OTHERS = "<gold><targetplayer><yellow>'s nickname was changed to <nickname><yellow>.";
public static String NICK_TARGET_NICK_CHANGE = "<yellow>Your nickname was changed to <nickname> <yellow>by <sendernick><yellow>";
public static String NICK_RESET_OTHERS = "<gold><player><gold>'s <yellow>nickname was reset back to normal.";
public static String NICK_INVALID_CHARACTERS = "<yellow>You can only use letters and numbers in nicknames.";
public static String NICK_INVALID_LENGTH = "<yellow>Nicknames need to be between 3 to 16 characters long.";
public static String NICK_PLAYER_NOT_ONLINE = "<red>That player is not online.";
public static String NICK_BLOCKED_COLOR_CODES = "<yellow>You have blocked color codes in that nickname.";
public static String NICK_USER_NOT_FOUND =
"<red>Failed to set nickname from player, try again from a server this player has been on before.";
public static String NICK_ACCEPTED =
"<green>You accepted <targetplayer><green>'s nickname. They are now called <newnick><green>.";
public static String NICK_DENIED =
"<green>You denied <targetplayer><green>'s nickname. They are still called <oldnick><green>.";
public static String NICK_USER_NOT_FOUND = "<red>Failed to set nickname from player, try again from a server this player has been on before.";
public static String NICK_ACCEPTED = "<green>You accepted <targetplayer><green>'s nickname. They are now called <newnick><green>.";
public static String NICK_DENIED = "<green>You denied <targetplayer><green>'s nickname. They are still called <oldnick><green>.";
public static String NICK_ALREADY_HANDLED = "<red><targetplayer><red>'s nickname was already accepted or denied.";
public static String NICK_NO_LUCKPERMS = "<red>Due to an issue with LuckPerms /nick try won't work at the moment.";
public static String NICK_TOO_SOON = "<red>Please wait <time><red> until requesting a new nickname";
public static String NICK_REQUEST_PLACED =
"<green>Replaced your previous request <oldrequestednick><green> with <newrequestednick><green>.";
public static String NICK_REQUEST_PLACED = "<green>Replaced your previous request <oldrequestednick><green> with <newrequestednick><green>.";
public static String NICK_REQUEST_NEW = "<green>New nickname request by <player><green>!";
public static String NICK_TRYOUT =
"<white><prefix><white> <nick><gray>: <white><click:suggest_command:/nick request <nickrequest>>Hi, this is what my new nickname could look like! Click this message to request.";
public static String NICK_REQUESTED =
"<green>Your requested to be nicknamed <nick><green> has been received. Staff will accept or deny this request asap!";
public static String NICK_TRYOUT = "<white><prefix><white> <nick><gray>: <white>Hi, this is what my new nickname could look like!";
public static String NICK_REQUESTED = "<green>Your requested to be nicknamed <nick><green> has been received. Staff will accept or deny this request asap!";
public static String NICK_REVIEW_WAITING = "<green>There are <amount> nicknames waiting for review!";
public static String NICK_TAKEN =
"<red>Someone else already has this nickname, or has this name as their username.";
public static String NICK_TAKEN = "<red>Someone else already has this nickname, or has this name as their username.";
public static String NICK_REQUESTS_ON_LOGIN = "<green>Current nick requests: <amount>";
public static long NICK_WAIT_TIME = 86400000;
public static List<String> NICK_ITEM_LORE = new ArrayList<>();
public static List<String> NICK_BLOCKED_COLOR_CODESLIST = new ArrayList<>();
public static List<String> NICK_ALLOWED_COLOR_CODESLIST = new ArrayList<>();
public static String NICK_CURRENT =
"<gold>Current nickname: <nickname><white>(<insert:\"<currentnickname>\"><currentnickname></insert>)";
public static String NICK_CURRENT = "<gold>Current nickname: <nickname><white>(<insert:\"<currentnickname>\"><currentnickname></insert>)";
private static void nicknameSettings() {
NICK_CHANGED = getString("nicknames.messages.nick-changed", NICK_CHANGED);
NICK_NOT_CHANGED = getString("nicknames.messages.nick-not-changed", NICK_NOT_CHANGED);
@ -615,30 +538,9 @@ public final class Config {
NICK_TAKEN = getString("nicknames.messages.nick-taken", NICK_TAKEN);
NICK_REQUESTS_ON_LOGIN = getString("nicknames.messages.nick-reauests-on-login", NICK_REQUESTS_ON_LOGIN);
NICK_WAIT_TIME = getLong("nicknames.wait-time", NICK_WAIT_TIME);
NICK_ITEM_LORE = getList("nicknames.item-lore",
List.of("<aqua>New nick: <newnick>", "<aqua>Old nick: <oldnick>", "<aqua>Last changed: <lastchanged>",
"<green>Left click to Accept <light_purple>| <red>Right click to Deny"));
NICK_ITEM_LORE = getList("nicknames.item-lore", List.of("<aqua>New nick: <newnick>", "<aqua>Old nick: <oldnick>", "<aqua>Last changed: <lastchanged>", "<green>Left click to Accept <light_purple>| <red>Right click to Deny"));
NICK_BLOCKED_COLOR_CODESLIST = getList("nicknames.blocked-color-codes", List.of("&k", "&l", "&n", "&m", "&o"));
NICK_ALLOWED_COLOR_CODESLIST = getList("nicknames.allowed-color-codes",
List.of("&0", "&1", "&2", "&3", "&4", "&5", "&6", "&7", "&8", "&9", "&a", "&b", "&c", "&d", "&e", "&f",
"&r"));
NICK_ALLOWED_COLOR_CODESLIST = getList("nicknames.allowed-color-codes", List.of("&0", "&1", "&2", "&3", "&4", "&5", "&6", "&7", "&8", "&9", "&a", "&b", "&c", "&d", "&e", "&f", "&r"));
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);
}
}

7
api/src/main/java/com/alttd/chat/config/RegexConfig.java
View File

@ -178,18 +178,13 @@ public final class RegexConfig {
String regex = entry.getValue().node("regex").getString();
String replacement = entry.getValue().node("replacement").getString();
List<String> exclusions = entry.getValue().node("exclusions").getList(io.leangen.geantyref.TypeToken.get(String.class), new ArrayList<>());
boolean disableInPrivate = false;
ConfigurationNode node = entry.getValue().node("disable-in-private");
if (node != null) {
disableInPrivate = node.getBoolean();
}
if (type == null || type.isEmpty() || regex == null || regex.isEmpty()) {
ALogger.warn("Filter: " + name + " was set up incorrectly");
} else {
if (replacement == null || replacement.isEmpty()) {
replacement = name;
}
ChatFilter chatFilter = new ChatFilter(name, type, regex, replacement, exclusions, disableInPrivate);
ChatFilter chatFilter = new ChatFilter(name, type, regex, replacement, exclusions);
RegexManager.addFilter(chatFilter);
}
} catch(SerializationException ex) {

98
api/src/main/java/com/alttd/chat/database/ChatLogQueries.java
View File

@ -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);
}
});
}
}

16
api/src/main/java/com/alttd/chat/database/DatabaseConnection.java
View File

@ -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
*/

1
api/src/main/java/com/alttd/chat/database/Queries.java
View File

@ -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();

31
api/src/main/java/com/alttd/chat/managers/RegexManager.java
View File

@ -8,13 +8,10 @@ import com.alttd.chat.objects.ModifiableString;
import com.alttd.chat.util.ALogger;
import net.luckperms.api.cacheddata.CachedPermissionData;
import net.luckperms.api.model.user.User;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.regex.Pattern;
public class RegexManager {
@ -46,24 +43,17 @@ public class RegexManager {
}
public static boolean filterText(String playerName, UUID uuid, ModifiableString modifiableString, String channel) { // TODO loop all objects in the list and check if they violate based on the MATCHER
return filterText(playerName, uuid, modifiableString, true, channel, null);
return filterText(playerName, uuid, modifiableString, true, channel);
}
public static boolean filterText(String playerName, UUID uuid, ModifiableString modifiableString, boolean matcher, String channel) {
return filterText(playerName, uuid, modifiableString, matcher, channel, null);
}
public static boolean filterText(String playerName, UUID uuid, ModifiableString modifiableString, boolean matcher, String channel, Consumer<FilterType> filterAction) {
User user = ChatAPI.get().getLuckPerms().getUserManager().getUser(uuid);
if (user == null) {
ALogger.warn("Tried to check chat filters for a user who doesn't exist in LuckPerms");
return false;
}
CachedPermissionData permissionData = user.getCachedData().getPermissionData();
boolean isPrivate = channel.equals("party");
for(ChatFilter chatFilter : chatFilters) {
if (isPrivate && chatFilter.isDisabledInPrivate())
continue;
switch (chatFilter.getType()) {
case CHAT:
break;
@ -84,25 +74,6 @@ public class RegexManager {
chatFilter.replaceMatcher(modifiableString);
}
break;
case PUNISH:
if (permissionData.checkPermission("chat.bypass-punish").asBoolean())
break;
if (chatFilter.matches(modifiableString)) {
ALogger.info(playerName + " triggered the punish filter for " + chatFilter.getName()
+ " with: " + modifiableString.string() + ".");
if (filterAction == null){
ALogger.info("No filterAction was provided, not doing anything");
return false;
}
Player player = Bukkit.getPlayer(uuid);
if (player == null) {
ALogger.warn("Tried to punish a player who triggered the filter, but the player is offline.");
return false;
}
filterAction.accept(FilterType.PUNISH);
return false;
}
}
}
return true;

10
api/src/main/java/com/alttd/chat/objects/BatchInsertable.java
View File

@ -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;
}

8
api/src/main/java/com/alttd/chat/objects/ChatFilter.java
View File

@ -17,16 +17,14 @@ public class ChatFilter {
private final Pattern pattern;
private final String replacement;
private final List<String> exclusions;
private final boolean disableInPrivate;
public ChatFilter(String name, String type, String regex, String replacement, List<String> exclusions, boolean disableInPrivate) {
public ChatFilter(String name, String type, String regex, String replacement, List<String> exclusions) {
this.name = name;
this.filterType = FilterType.getType(type);
this.regex = regex;
this.pattern = Pattern.compile(getRegex(), Pattern.CASE_INSENSITIVE);
this.replacement = replacement;
this.exclusions = exclusions;
this.disableInPrivate = disableInPrivate;
}
public String getName() {
@ -49,10 +47,6 @@ public class ChatFilter {
return this.exclusions;
}
public boolean isDisabledInPrivate() {
return disableInPrivate;
}
public boolean matches(ModifiableString filterableString) {
String input = filterableString.string();
Matcher matcher = pattern.matcher(input);

29
api/src/main/java/com/alttd/chat/objects/ChatUser.java
View File

@ -3,7 +3,7 @@ package com.alttd.chat.objects;
import com.alttd.chat.database.Queries;
import com.alttd.chat.objects.channels.Channel;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import java.util.ArrayList;
import java.util.List;
@ -13,9 +13,9 @@ import java.util.stream.Collectors;
public class ChatUser {
private final UUID uuid; // player uuid
private int partyId; // the party they are in
private final Channel toggledChannel;
private Channel toggledChannel;
private String name; // the nickname, doesn't need to be saved with the chatuser object, could be saved but we can get it from the nicknamesview
private ComponentLike displayName; // the nickname, doesn't need to be saved with the chatuser object, could be saved but we can get it from the nicknamesview
private Component displayName; // the nickname, doesn't need to be saved with the chatuser object, could be saved but we can get it from the nicknamesview
// private Component prefix; // doesn't need saving, we get this from luckperms
// private Component staffPrefix; // doesn't need saving, we get this from luckperms
// private Component prefixAll; // doesn't need saving, we get this from luckperms
@ -24,9 +24,9 @@ public class ChatUser {
private String replyContinueTarget; // reply target for use in /c
private long gcCooldown; // the time when they last used gc, is used for the cooldown, i wouldn't save this, but setting this to the login time means they can't use gc for 30 seconds after logging in
private boolean spy;
private final List<Mail> mails; // mails aren't finalized yet, so for now a table sender, reciever, sendtime, readtime(if emtpy mail isn't read yet?, could also do a byte to control this), the actual message
private final List<UUID> ignoredPlayers; // a list of UUID, a new table non unique, where one is is the player select * from ignores where ignoredby = thisplayer? where the result is the uuid of the player ignored by this player?
private final List<UUID> ignoredBy; // a list of UUID, same table as above but select * from ignores where ignored = thisplayer? result should be the other user that ignored this player?
private List<Mail> mails; // mails aren't finalized yet, so for now a table sender, reciever, sendtime, readtime(if emtpy mail isn't read yet?, could also do a byte to control this), the actual message
private List<UUID> ignoredPlayers; // a list of UUID, a new table non unique, where one is is the player select * from ignores where ignoredby = thisplayer? where the result is the uuid of the player ignored by this player?
private List<UUID> ignoredBy; // a list of UUID, same table as above but select * from ignores where ignored = thisplayer? result should be the other user that ignored this player?
private boolean isMuted;
public ChatUser(UUID uuid, int partyId, Channel toggledChannel) {
@ -71,7 +71,12 @@ public class ChatUser {
return toggledChannel;
}
public ComponentLike getDisplayName() {
public void setToggledChannel(Channel channel) {
toggledChannel = channel;
Queries.setToggledChannel(toggledChannel, uuid); //TODO: Async pls - no CompleteableFuture<>!
}
public Component getDisplayName() {
return displayName;
}
@ -79,17 +84,17 @@ public class ChatUser {
this.displayName = Utility.applyColor(displayName);
}
public ComponentLike getPrefix() {
public Component getPrefix() {
//return prefix;
return Utility.getPrefix(uuid, true); // No longer cache this data
}
public ComponentLike getStaffPrefix() {
public Component getStaffPrefix() {
//return staffPrefix;
return Utility.getStaffPrefix(uuid);
}
public ComponentLike getPrefixAll() {
public Component getPrefixAll() {
//return prefixAll;
return Utility.getPrefix(uuid, false);
}
@ -140,6 +145,10 @@ public class ChatUser {
return ignoredBy;
}
public void addIgnoredBy(UUID uuid) {
ignoredBy.add(uuid);
}
public long getGcCooldown() {
return gcCooldown;
}

8
api/src/main/java/com/alttd/chat/objects/EmoteList.java
View File

@ -4,9 +4,9 @@ import com.alttd.chat.config.Config;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import org.bukkit.Bukkit;
import java.util.HashMap;
import java.util.Map;
@ -25,8 +25,7 @@ public class EmoteList {
}
private int page;
public ComponentLike showEmotePage() {
public Component showEmotePage() {
int startIndex = page * pageSize;
int pages = RegexManager.getEmoteFilters().size() / pageSize;
int endIndex = Math.min(startIndex + pageSize, RegexManager.getEmoteFilters().size());
@ -34,7 +33,7 @@ public class EmoteList {
Placeholder.unparsed("page", String.valueOf(page)),
Placeholder.unparsed("pages", String.valueOf(pages))
);
Component list = Utility.parseMiniMessage(Config.EMOTELIST_HEADER, placeholders).asComponent();
Component list = Utility.parseMiniMessage(Config.EMOTELIST_HEADER, placeholders);
for (int i = startIndex; i < endIndex; i++) {
ChatFilter emote = RegexManager.getEmoteFilters().get(i);
@ -61,4 +60,5 @@ public class EmoteList {
this.page = Math.max(page - 1, 0);
}
}

3
api/src/main/java/com/alttd/chat/objects/FilterType.java
View File

@ -5,8 +5,7 @@ public enum FilterType {
EMOTE("emote"),
CHAT("chat"),
REPLACEMATCHER("replacematcher"),
BLOCK("block"),
PUNISH("punish");
BLOCK("block");
private final String name;

4
api/src/main/java/com/alttd/chat/objects/ModifiableString.java
View File

@ -3,6 +3,10 @@ package com.alttd.chat.objects;
import net.kyori.adventure.text.Component;
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;
public class ModifiableString {
private Component text;

8
api/src/main/java/com/alttd/chat/objects/PartyUser.java
View File

@ -1,21 +1,21 @@
package com.alttd.chat.objects;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import java.util.UUID;
public class PartyUser {
protected UUID uuid;
protected ComponentLike displayName;
protected Component displayName;
protected String playerName;
public PartyUser(UUID uuid, String displayName, String playerName) {
this(uuid, Utility.applyColor(displayName), playerName);
}
public PartyUser(UUID uuid, ComponentLike displayName, String playerName) {
public PartyUser(UUID uuid, Component displayName, String playerName) {
this.uuid = uuid;
this.displayName = displayName;
this.playerName = playerName;
@ -25,7 +25,7 @@ public class PartyUser {
return uuid;
}
public ComponentLike getDisplayName() {
public Component getDisplayName() {
return displayName;
}

8
api/src/main/java/com/alttd/chat/objects/channels/Channel.java
View File

@ -10,14 +10,12 @@ public class Channel {
protected String channelName;
protected String format;
protected boolean proxy;
protected boolean local;
public Channel(String channelName, String format, boolean proxy, boolean local) {
public Channel(String channelName, String format, boolean proxy) {
this.permission = "chat.channel." + channelName.toLowerCase();
this.channelName = channelName;
this.format = format;
this.proxy = proxy;
this.local = local;
channels.put(channelName.toLowerCase(), this);
}
@ -41,10 +39,6 @@ public class Channel {
return proxy;
}
public boolean isLocal() {
return local;
}
public static Channel getChatChannel(String channelName) {
return channels.get(channelName.toLowerCase());
}

15
api/src/main/java/com/alttd/chat/objects/channels/CustomChannel.java
View File

@ -1,27 +1,20 @@
package com.alttd.chat.objects.channels;
import java.util.List;
import java.util.*;
public class CustomChannel extends Channel {
private final List<String> servers;
private final List<String> aliases;
public CustomChannel(String channelName, String format, List<String> servers, List<String> aliases, boolean proxy,
boolean local) {
super(channelName, format, proxy, local);
public CustomChannel(String channelName, String format, List<String> servers, boolean proxy) {
super(channelName, format, proxy);
this.permission = "chat.channel." + channelName.toLowerCase();
this.channelName = channelName;
this.format = format;
this.servers = servers;
this.proxy = proxy;
this.aliases = aliases;
channels.put(channelName.toLowerCase(), this);
}
public List<String> getServers() {
return servers;
}
public List<String> getAliases() {
return aliases;
}
}

2
api/src/main/java/com/alttd/chat/objects/channels/DefaultChannel.java
View File

@ -2,6 +2,6 @@ package com.alttd.chat.objects.channels;
public abstract class DefaultChannel extends Channel{
public DefaultChannel(String channelName, String format, boolean proxy) {
super(channelName, format, proxy, false);
super(channelName, format, proxy);
}
}

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

@ -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;
}
}

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

@ -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);
});
}
}

8
api/src/main/java/com/alttd/chat/util/ALogger.java
View File

@ -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);
}
}

100
api/src/main/java/com/alttd/chat/util/Utility.java
View File

@ -3,30 +3,32 @@ package com.alttd.chat.util;
import com.alttd.chat.ChatAPI;
import com.alttd.chat.config.Config;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.format.TextDecoration;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.luckperms.api.LuckPerms;
import net.luckperms.api.model.group.Group;
import net.luckperms.api.model.user.User;
import net.luckperms.api.node.Node;
import org.bukkit.permissions.Permission;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class Utility {
private static final List<String> EMPTY_LIST = new ArrayList<>();
static final Pattern DEFAULT_URL_PATTERN = Pattern.compile("(https?://)?[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_+.~#?&/=]*)");
static final Pattern DEFAULT_URL_PATTERN = Pattern.compile("(?:(https?)://)?([-\\w_.]+\\.\\w{2,})(/\\S*)?");
private static MiniMessage miniMessage = null;
public static String stringRegen = "\\{#[A-Fa-f0-9]{6}(<)?(>)?}";
public static HashMap<String, String> colors;
private static LegacyComponentSerializer legacySerializer;
static { // this might be in minimessage already?
colors = new HashMap<>();
colors.put("&0", "<black>");
@ -48,7 +50,6 @@ public class Utility {
}
public static HashMap<String, Pair<TagResolver, List<String>>> formattingPerms = new HashMap<>();
static {
formattingPerms.put("chat.format.color",
new Pair<>(StandardTags.color(), colors.values().stream().toList()));
@ -81,9 +82,7 @@ public class Utility {
}
public static String parseColors(String message) {
if (message == null) {
return "";
}
if (message == null) return "";
// split string in sections and check those vs looping hashmap?:/
// think this is better, but will check numbers on this
for (String key : colors.keySet()) {
@ -94,17 +93,15 @@ public class Utility {
return message;
}
public static ComponentLike getPrefix(UUID uuid, boolean single) {
public static Component getPrefix(UUID uuid, boolean single) {
StringBuilder prefix = new StringBuilder();
LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid);
List<String> prefixGroups = Config.PREFIXGROUPS;
if (user == null) {
return Component.empty();
}
if(user == null) return Component.empty();
if(!single) {
Collection<Group> inheritedGroups = user.getInheritedGroups(user.getQueryOptions());
if (inheritedGroups.stream().anyMatch(group -> group.getName().equals("eventleader"))) {
if(inheritedGroups.stream().map(Group::getName).collect(Collectors.toList()).contains("eventleader")) {
prefixGroups.remove("eventteam"); // hardcoded for now, new prefix system would load this from config
}
inheritedGroups.stream()
@ -116,22 +113,20 @@ public class Utility {
});
}
prefix.append(getUserPrefix(user));
// prefix.append(user.getCachedData().getMetaData().getPrefix());
return applyColor(prefix.toString());
}
public static ComponentLike getStaffPrefix(UUID uuid) {
public static Component getStaffPrefix(UUID uuid) {
StringBuilder prefix = new StringBuilder();
LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid);
if (user == null) {
return Component.empty();
}
if(user == null) return Component.empty();
if(user.getCachedData().getPermissionData().checkPermission("group." + Config.MINIMIUMSTAFFRANK).asBoolean()) {
Group group = luckPerms.getGroupManager().getGroup(user.getPrimaryGroup());
if (group != null) {
if(group != null)
prefix.append(getGroupPrefix(group));
}
// prefix.append(group.getCachedData().getMetaData().getPrefix());
}
return applyColor(prefix.toString());
@ -143,32 +138,26 @@ public class Utility {
if (group == null) {
return "";
}
String prefix = user.getCachedData().getMetaData().getPrefix();
if (prefix == null) {
ALogger.warn("User " + user.getUsername() + " has no prefix set!");
return ChatAPI.get().getPrefixes().get(group.getName()).replace("<prefix>", user.getCachedData().getMetaData().getPrefix());
}
public static String getGroupPrefix(String groupName) {
Group group = ChatAPI.get().getLuckPerms().getGroupManager().getGroup(groupName);
if (group == null) {
return "";
}
return ChatAPI.get().getPrefixes().get(group.getName()).replace("<prefix>", prefix);
return getGroupPrefix(group);
}
public static String getGroupPrefix(Group group) {
String prefix = group.getCachedData().getMetaData().getPrefix();
if (prefix == null) {
ALogger.warn("Group " + group.getName() + " has no prefix set!");
return "";
}
return ChatAPI.get().getPrefixes().get(group.getName()).replace("<prefix>", prefix);
return ChatAPI.get().getPrefixes().get(group.getName()).replace("<prefix>", group.getCachedData().getMetaData().getPrefix());
}
public static String getDisplayName(UUID uuid, String playerName) {
if (!playerName.isBlank()) {
return playerName;
}
if (!playerName.isBlank()) return playerName;
LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid);
if (user == null) {
return "";
}
if(user == null) return "";
return user.getUsername();
}
@ -183,15 +172,13 @@ public class Utility {
public static boolean hasPermission(UUID uuid, String permission) {
LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid);
if (user == null) {
return false;
}
if(user == null) return false;
return user.getCachedData().getPermissionData().checkPermission(permission).asBoolean();
}
public static ComponentLike applyColor(String message) {
public static Component applyColor(String message) {
String hexColor1 = "";
String hexColor2;
String hexColor2 = "";
StringBuilder stringBuilder = new StringBuilder();
message = parseColors(message);
boolean startsWithColor = false;
@ -258,7 +245,7 @@ public class Utility {
stringBuilder.append("<").append(hexColor1).append(">").append(split[i]);
}
}
return stringBuilder.isEmpty() ? Utility.parseMiniMessage(message)
return stringBuilder.length() == 0 ? Utility.parseMiniMessage(message)
: Utility.parseMiniMessage(stringBuilder.toString());
}
@ -304,29 +291,32 @@ public class Utility {
}
public static String formatText(String message) {
/*
.match(pattern)
.replacement(url -> {
String clickUrl = url.content();
if (!URL_SCHEME_PATTERN.matcher(clickUrl).find()) {
clickUrl = "http://" + clickUrl;
}
return (style == null ? url : url.style(style)).clickEvent(ClickEvent.openUrl(clickUrl));
})
.build();
*/
Matcher matcher = DEFAULT_URL_PATTERN.matcher(message);
while (matcher.find()) {
String url = matcher.group();
String clickUrl = url;
String urlFormat = Config.URLFORMAT;
message = message.replace(url, urlFormat
.replaceAll("<url>", "<u>" + url + "</u>")
.replaceAll("<clickurl>", formatUrl(url)));
message = message.replace(url, urlFormat.replaceAll("<url>", url).replaceAll("<clickurl>", clickUrl));
}
return message;
}
private static String formatUrl(String url) {
if (url.startsWith("http://") || url.startsWith("https://")) {
return url;
}
return "https://" + url;
}
public static ComponentLike parseMiniMessage(String message) {
public static Component parseMiniMessage(String message) {
return getMiniMessage().deserialize(message);
}
public static ComponentLike parseMiniMessage(String message, TagResolver placeholders) {
public static Component parseMiniMessage(String message, TagResolver placeholders) {
if (placeholders == null) {
return getMiniMessage().deserialize(message);
} else {
@ -334,7 +324,7 @@ public class Utility {
}
}
public static ComponentLike parseMiniMessage(String message, TagResolver... placeholders) {
public static Component parseMiniMessage(String message, TagResolver ... placeholders) {
if (placeholders == null) {
return getMiniMessage().deserialize(message);
} else {
@ -347,9 +337,7 @@ public class Utility {
}
public static MiniMessage getMiniMessage() {
if (miniMessage == null) {
miniMessage = MiniMessage.miniMessage();
}
if (miniMessage == null) miniMessage = MiniMessage.miniMessage();
return miniMessage;
}

18
build.gradle.kts
View File

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

46
galaxy/build.gradle.kts
View File

@ -1,26 +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.cosmos:cosmos-api:1.21.8-R0.1-SNAPSHOT") {
isChanging = true
}
compileOnly("com.gitlab.ruany:LiteBansAPI:0.6.1") // move to proxy
compileOnly("org.apache.commons:commons-lang3:3.17.0") // needs an alternative, already removed from upstream api and will be removed in server
compileOnly("net.luckperms:api:5.5") // Luckperms
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)
}
}
}

53
galaxy/src/main/java/com/alttd/chat/ChatPlugin.java
View File

@ -5,21 +5,24 @@ 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.requests.RequestHandler;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.ServerName;
import com.alttd.chat.util.Utility;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.PluginCommand;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.Objects;
import java.util.List;
public class ChatPlugin extends JavaPlugin {
@ -27,7 +30,9 @@ public class ChatPlugin extends JavaPlugin {
private ChatAPI chatAPI;
private ChatHandler chatHandler;
private RequestHandler requestHandler;
private String messageChannel;
private ServerConfig serverConfig;
@Override
@ -37,9 +42,10 @@ public class ChatPlugin extends JavaPlugin {
chatAPI = new ChatImplementation();
chatHandler = new ChatHandler();
DatabaseConnection.initialize();
serverConfig = new ServerConfig(ServerName.getServerName());
ChatLogHandler chatLogHandler = ChatLogHandler.getInstance(true);
registerListener(new PlayerListener(serverConfig), new ChatListener(chatLogHandler), new BookListener(), new ShutdownListener(chatLogHandler, this));
requestHandler = new RequestHandler();
requestHandler.loadRequests();
serverConfig = new ServerConfig(Bukkit.getServerName());
registerListener(new PlayerListener(serverConfig), new ChatListener(), new BookListener());
if(serverConfig.GLOBALCHAT) {
registerCommand("globalchat", new GlobalChat());
registerCommand("toggleglobalchat", new ToggleGlobalChat());
@ -52,16 +58,15 @@ public class ChatPlugin extends JavaPlugin {
registerCommand("muteserver", new MuteServer());
registerCommand("spy", new Spy());
registerCommand("chatclear", new ChatClear());
// registerCommand("chatparty", new ChatParty());
registerCommand("p", new PartyChat());
registerCommand("emotes", new Emotes());
for (Channel channel : Channel.getChannels()) {
if (!(channel instanceof CustomChannel customChannel)) {
continue;
}
if (!(channel instanceof CustomChannel customChannel)) continue;
this.getServer().getCommandMap().register(channel.getChannelName().toLowerCase(), new ChatChannel(customChannel));
}
String messageChannel = Config.MESSAGECHANNEL;
messageChannel = Config.MESSAGECHANNEL;
getServer().getMessenger().registerOutgoingPluginChannel(this, messageChannel);
getServer().getMessenger().registerIncomingPluginChannel(this, messageChannel, new PluginMessage());
@ -83,17 +88,31 @@ public class ChatPlugin extends JavaPlugin {
}
public void registerCommand(String commandName, CommandExecutor commandExecutor) {
Objects.requireNonNull(getCommand(commandName)).setExecutor(commandExecutor);
getCommand(commandName).setExecutor(commandExecutor);
}
public void registerCommand(String commandName, CommandExecutor commandExecutor, List<String> aliases) {
PluginCommand command = getCommand(commandName);
command.setAliases(aliases);
command.setExecutor(commandExecutor);
}
public static ChatPlugin getInstance() {
return instance;
}
public ChatAPI getChatAPI() {
return chatAPI;
}
public ChatHandler getChatHandler() {
return chatHandler;
}
public RequestHandler getRequestHandler() {
return requestHandler;
}
public boolean serverGlobalChatEnabled() {
return serverConfig.GLOBALCHAT;
}
@ -106,11 +125,11 @@ public class ChatPlugin extends JavaPlugin {
serverConfig.MUTED = !serverConfig.MUTED;
}
public void reloadConfig() {
chatAPI.reloadConfig();
chatAPI.reloadChatFilters();
serverConfig = new ServerConfig(ServerName.getServerName());
Bukkit.broadcast(Utility.parseMiniMessage("Reloaded ChatPlugin Config.").asComponent(), "command.chat.reloadchat");
public void ReloadConfig() {
chatAPI.ReloadConfig();
chatAPI.ReloadChatFilters();
serverConfig = new ServerConfig(Bukkit.getServerName());
Bukkit.broadcast(Utility.parseMiniMessage("Reloaded ChatPlugin Config."), "command.chat.reloadchat");
ALogger.info("Reloaded ChatPlugin config.");
}
}

9
galaxy/src/main/java/com/alttd/chat/commands/ChatChannel.java
View File

@ -11,15 +11,14 @@ import org.bukkit.command.defaults.BukkitCommand;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.*;
public class ChatChannel extends BukkitCommand {
CustomChannel channel;
String command;
ToggleableForCustomChannel toggleableForCustomChannel;
private static final List<ChatChannel> activeCommands = new ArrayList<>();
private static List<ChatChannel> activeCommands = new ArrayList<>();
public ChatChannel(CustomChannel channel) {
super(channel.getChannelName().toLowerCase());
@ -27,7 +26,7 @@ public class ChatChannel extends BukkitCommand {
this.command = channel.getChannelName().toLowerCase();
this.description = "Chat channel named " + channel.getChannelName() + ".";
this.usageMessage = "/" + command + " <message>";
this.setAliases(channel.getAliases());
this.setAliases(Collections.emptyList());
activeCommands.add(this);
this.toggleableForCustomChannel = new ToggleableForCustomChannel(channel);
}
@ -39,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)));

14
galaxy/src/main/java/com/alttd/chat/commands/ChatClear.java
View File

@ -1,5 +1,6 @@
package com.alttd.chat.commands;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
@ -8,24 +9,21 @@ import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class ChatClear implements CommandExecutor {
private static final Component component = MiniMessage.miniMessage().deserialize("\n".repeat(100));
private static final Component component = MiniMessage.miniMessage().deserialize("\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n");
MiniMessage miniMessage = MiniMessage.miniMessage();
@Override
public boolean onCommand(CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (!sender.hasPermission("chat.command.clear-chat")) {
sender.sendRichMessage("<red>You don't have permission to use this command.</red>");
sender.sendMessage(Utility.parseMiniMessage("<red>You don't have permission to use this command.</red>"));
return true;
}
for (Player player : Bukkit.getOnlinePlayers()) {
if (!player.hasPermission("chat.clear-bypass")) {
for (Player player : Bukkit.getOnlinePlayers())
if (!player.hasPermission("chat.clear-bypass"))
player.sendMessage(component);
}
}
Bukkit.getServer().sendMessage(miniMessage.deserialize(
"<gold><player> cleared chat.</gold>",

11
galaxy/src/main/java/com/alttd/chat/commands/Continue.java
View File

@ -8,22 +8,17 @@ import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class Continue implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player player)) {
return true;
}
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
if (user.getReplyContinueTarget() == null) {
return false;
}
if (args.length == 0) {
return false; // todo error message or command info
}
if (user.getReplyContinueTarget() == null) return false;
if(args.length == 0) return false; // todo error message or command info
String message = StringUtils.join(args, " ", 0, args.length);
ChatPlugin.getInstance().getChatHandler().continuePrivateMessage(player, user.getReplyContinueTarget(), message);

7
galaxy/src/main/java/com/alttd/chat/commands/GlobalChat.java
View File

@ -7,18 +7,15 @@ import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
public class GlobalChat implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player player)) { // must be a player
return true;
}
if (args.length == 0) {
return false;
}
if(args.length == 0) return false;
String message = StringUtils.join(args, " ", 0, args.length);

18
galaxy/src/main/java/com/alttd/chat/commands/Ignore.java
View File

@ -5,17 +5,19 @@ 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.util.Utility;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import java.util.HashSet;
import java.util.List;
import java.util.UUID;
public class Ignore implements CommandExecutor {
@ -27,13 +29,11 @@ public class Ignore implements CommandExecutor {
}
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
if (!(sender instanceof Player player)) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player player)) { // must be a player
return true;
}
if (args.length > 1) {
return false; // todo error message or command info
}
if(args.length > 1) return false; // todo error message or command info
String targetName = args[0];
if (targetName.equals("?")) {
new BukkitRunnable() {
@ -44,7 +44,7 @@ public class Ignore implements CommandExecutor {
StringBuilder ignoredMessage = new StringBuilder();
if (userNames.isEmpty()) {
player.sendRichMessage("You don't have anyone ignored!"); //TODO load from config
player.sendMessage(Utility.parseMiniMessage("You don't have anyone ignored!")); //TODO load from config
return;
}
@ -52,7 +52,7 @@ public class Ignore implements CommandExecutor {
userNames.forEach(username -> ignoredMessage.append(username).append("\n"));
ignoredMessage.delete(ignoredMessage.length() - 1, ignoredMessage.length());
player.sendRichMessage(ignoredMessage.toString());
player.sendMessage(Utility.parseMiniMessage(ignoredMessage.toString()));
}
}.runTaskAsynchronously(plugin);
return false;
@ -76,7 +76,7 @@ public class Ignore implements CommandExecutor {
ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId());
if(!chatUser.getIgnoredPlayers().contains(target)) {
chatUser.addIgnoredPlayers(target);
Queries.ignoreUser(player.getUniqueId(), target);
Queries.ignoreUser(((Player) sender).getUniqueId(), target);
sender.sendMessage("You have ignored " + targetName + "."); // TODO load from config and minimessage
sendPluginMessage("ignore", player, target);
} else {

7
galaxy/src/main/java/com/alttd/chat/commands/Message.java
View File

@ -8,18 +8,15 @@ import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class Message implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player player)) {
return true;
}
if (args.length < 2) {
return false; // todo error message or command info
}
if(args.length < 2) return false; // todo error message or command info
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
user.setReplyContinueTarget(args[0]);

10
galaxy/src/main/java/com/alttd/chat/commands/MuteServer.java
View File

@ -3,21 +3,21 @@ package com.alttd.chat.commands;
import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import java.util.UUID;
public class MuteServer implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player player)) { // must be a player
return true;
}
@ -26,13 +26,13 @@ public class MuteServer implements CommandExecutor {
public void run() {
UUID uuid = player.getUniqueId();
if (!Utility.hasPermission(uuid, Config.SERVERMUTEPERMISSION)) {
sender.sendRichMessage("<red>You don't have permission to use this command.</red>");
sender.sendMessage(Utility.parseMiniMessage("<red>You don't have permission to use this command.</red>"));
return;
}
ChatPlugin.getInstance().toggleServerMuted();
ComponentLike component;
Component component;
if (ChatPlugin.getInstance().serverMuted()) {
component = Utility.parseMiniMessage(Utility.getDisplayName(player.getUniqueId(), player.getName()) + " <red>muted</red><white> chat.");
} else {

2
galaxy/src/main/java/com/alttd/chat/commands/PartyChat.java
View File

@ -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;
}

14
galaxy/src/main/java/com/alttd/chat/commands/Reply.java
View File

@ -8,22 +8,18 @@ import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class Reply implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
if (!(sender instanceof Player player)) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player)) {
return true;
}
Player player = (Player) sender;
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
if (user.getReplyTarget() == null) {
return false;
}
if (args.length == 0) {
return false; // todo error message or command info
}
if (user.getReplyTarget() == null) return false;
if(args.length == 0) return false; // todo error message or command info
String message = StringUtils.join(args, " ", 0, args.length);
ChatPlugin.getInstance().getChatHandler().privateMessage(player, user.getReplyTarget(), message);

9
galaxy/src/main/java/com/alttd/chat/commands/Spy.java
View File

@ -1,29 +1,30 @@
package com.alttd.chat.commands;
import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import java.util.UUID;
public class Spy implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
if (!(sender instanceof Player player)) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player)) { // must be a player
return true;
}
new BukkitRunnable() {
@Override
public void run() {
UUID uuid = player.getUniqueId();
UUID uuid = ((Player) sender).getUniqueId();
ChatUser user = ChatUserManager.getChatUser(uuid);
user.toggleSpy();
sender.sendMessage(Utility.parseMiniMessage("You have turned spy " + (user.isSpy() ? "<green>on." : "<red>off."))); // TODO load from config and minimessage

17
galaxy/src/main/java/com/alttd/chat/commands/ToggleGlobalChat.java
View File

@ -2,31 +2,38 @@ package com.alttd.chat.commands;
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.util.Utility;
import jdk.jshell.execution.Util;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import java.util.Objects;
import java.util.UUID;
public class ToggleGlobalChat implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
if (!(sender instanceof Player)) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player)) { // must be a player
return true;
}
new BukkitRunnable() {
@Override
public void run() {
UUID uuid = ((Player) sender).getUniqueId();
ChatUserManager.getChatUser(uuid);
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
//chatUser.toggleGc();
Utility.flipPermission(uuid, Config.GCPERMISSION);
sender.sendRichMessage("You have turned globalchat " + (!Utility.hasPermission(uuid, Config.GCPERMISSION) ? "<green>on." : "<red>off.")); // TODO load from config and minimessage
//Queries.setGlobalChatState(chatUser.isGcOn(), chatUser.getUuid());
sender.sendMessage(Utility.parseMiniMessage("You have turned globalchat " + (!Utility.hasPermission(uuid, Config.GCPERMISSION) ? "<green>on." : "<red>off."))); // TODO load from config and minimessage
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
return false;

16
galaxy/src/main/java/com/alttd/chat/commands/Unignore.java
View File

@ -3,17 +3,21 @@ package com.alttd.chat.commands;
import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries;
import com.alttd.chat.listeners.PluginMessage;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.objects.ChatUser;
import com.google.common.io.ByteArrayDataOutput;
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.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.PluginCommand;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import java.util.UUID;
@ -26,15 +30,17 @@ public class Unignore implements CommandExecutor {
}
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if(!(sender instanceof Player player)) { // must be a player
return true;
}
if (args.length > 1) {
return false; // todo error message or command info
}
if(args.length > 1) return false; // todo error message or command info
String targetName = args[0];
UUID target = Bukkit.getOfflinePlayer(targetName).getUniqueId();
if(target == null) {
//sender.sendMessage("Target not found..."); // TODO load from config and minimessage
return false;
}
new BukkitRunnable() {
@Override
public void run() {

119
galaxy/src/main/java/com/alttd/chat/handler/ChatHandler.java
View File

@ -8,14 +8,11 @@ import com.alttd.chat.objects.ChatFilter;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.ModifiableString;
import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.GalaxyUtility;
import com.alttd.chat.util.ServerName;
import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
@ -23,23 +20,18 @@ import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
public class ChatHandler {
private final ChatPlugin plugin;
private final ComponentLike GCNOTENABLED;
private final Component GCNOTENABLED;
public ChatHandler() {
plugin = ChatPlugin.getInstance();
@ -56,9 +48,9 @@ public class ChatHandler {
Placeholder.parsed("receivername", target)
);
ComponentLike component = Utility.parseMiniMessage("<message>", placeholders);
Component component = Utility.parseMiniMessage("<message>", placeholders);
ModifiableString modifiableString = new ModifiableString(component.asComponent());
ModifiableString modifiableString = new ModifiableString(component);
// todo a better way for this
if(!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "privatemessage")) {
GalaxyUtility.sendBlockedNotification("DM Language",
@ -70,8 +62,8 @@ public class ChatHandler {
component = modifiableString.component();
sendPrivateMessage(player, target, "privatemessage", component.asComponent());
ComponentLike spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
sendPrivateMessage(player, target, "privatemessage", component);
Component spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
for(Player pl : Bukkit.getOnlinePlayers()) {
if(pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
pl.sendMessage(spymessage);
@ -106,7 +98,7 @@ public class ChatHandler {
// .replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand())).build());
sendPrivateMessage(player, target, "privatemessage", messageComponent);
ComponentLike spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
Component spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
for(Player pl : Bukkit.getOnlinePlayers()) {
if(pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
pl.sendMessage(spymessage);
@ -127,20 +119,21 @@ public class ChatHandler {
long timeLeft = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis() - user.getGcCooldown());
if(timeLeft <= Config.GCCOOLDOWN && !player.hasPermission("chat.globalchat.cooldownbypass")) { // player is on cooldown and should wait x seconds
player.sendRichMessage(Config.GCONCOOLDOWN, Placeholder.parsed("cooldown", Config.GCCOOLDOWN - timeLeft + ""));
player.sendMessage(Utility.parseMiniMessage(Config.GCONCOOLDOWN, Placeholder.parsed("cooldown", Config.GCCOOLDOWN-timeLeft+"")));
return;
}
ComponentLike senderName = user.getDisplayName();
ComponentLike prefix = user.getPrefix();
Component senderName = user.getDisplayName();
Component prefix = user.getPrefix();
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName),
Placeholder.component("prefix", prefix),
Placeholder.component("message", parseMessageContent(player, message)),
Placeholder.parsed("server", ServerName.getServerName())
Placeholder.parsed("server", Bukkit.getServerName())
);
Component component = Utility.parseMiniMessage(Config.GCFORMAT, placeholders).asComponent();
Component component = Utility.parseMiniMessage(Config.GCFORMAT, placeholders);
ModifiableString modifiableString = new ModifiableString(component);
// todo a better way for this
@ -159,25 +152,22 @@ public class ChatHandler {
public void chatChannel(Player player, CustomChannel channel, String message) {
if (!player.hasPermission(channel.getPermission())) {
player.sendRichMessage("<red>You don't have permission to use this channel.</red>");
player.sendMessage(Utility.parseMiniMessage("<red>You don't have permission to use this channel.</red>"));
return;
}
if (isMuted(player, message, "[" + channel.getChannelName() + " Muted] ")) {
ALogger.info("Refusing to send message by muted user");
return;
}
if (isMuted(player, message, "[" + channel.getChannelName() + " Muted] ")) return;
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
ComponentLike senderName = user.getDisplayName();
Component senderName = user.getDisplayName();
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName),
Placeholder.component("message", parseMessageContent(player, message)),
Placeholder.parsed("server", ServerName.getServerName()),
Placeholder.parsed("server", Bukkit.getServerName()),
Placeholder.parsed("channel", channel.getChannelName())
);
Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders).asComponent();
Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders);
ModifiableString modifiableString = new ModifiableString(component);
if(!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, channel.getChannelName())) {
@ -185,16 +175,15 @@ public class ChatHandler {
player,
Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
"");
ALogger.info("Refusing to send blocked chat message");
return;
return; // the message was blocked
}
component = modifiableString.component();
if (channel.isProxy()) {
sendChatChannelMessage(player, channel.getChannelName(), "chatchannel", component, message);
sendChatChannelMessage(player, channel.getChannelName(), "chatchannel", component);
} else {
sendChatChannelMessage(channel, player.getUniqueId(), component, message);
sendChatChannelMessage(channel, player.getUniqueId(), component);
}
}
@ -208,6 +197,7 @@ public class ChatHandler {
));
player.sendPluginMessage(plugin, Config.MESSAGECHANNEL, out.toByteArray());
// if (isMuted(player, message, "[" + party.getPartyName() + " Muted] ")) return;
//
// ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
@ -246,51 +236,13 @@ public class ChatHandler {
// }
}
private void sendChatChannelMessage(CustomChannel chatChannel, UUID uuid, ComponentLike component, String message) {
Player player = Bukkit.getPlayer(uuid);
if (player == null) {
ALogger.warn("Failed to send chat message from non existent player");
return;
}
private void sendChatChannelMessage(CustomChannel chatChannel, UUID uuid, Component component) {
if (!chatChannel.getServers().contains(Bukkit.getServerName())) return;
if (!chatChannel.getServers().contains(ServerName.getServerName())) {
player.sendRichMessage("<red>Unable to send messages to <channel> in this server.</red>",
Placeholder.parsed("channel", chatChannel.getChannelName()));
ALogger.info(String.format("Not sending chat message due to [%s] not being in this channels config",
ServerName.getServerName()));
return;
}
Stream<? extends Player> stream = Bukkit.getServer().getOnlinePlayers().stream()
.filter(p -> p.hasPermission(chatChannel.getPermission()));
if (!player.hasPermission("chat.ignorebypass")) {
stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid)
|| receiver.hasPermission("chat.ignorebypass"));
}
if (chatChannel.isLocal()) {
Location location = player.getLocation();
stream = stream.filter(receiver -> {
Player receiverPlayer = Bukkit.getPlayer(receiver.getUniqueId());
if (receiverPlayer == null) {
return false;
}
if (!location.getWorld().getUID().equals(receiverPlayer.getLocation().getWorld().getUID())) {
return false;
}
return !(receiverPlayer.getLocation().distance(location) > Config.LOCAL_DISTANCE);
});
}
List<? extends Player> recipientPlayers = stream.toList();
recipientPlayers.forEach(p -> p.sendMessage(component));
List<UUID> recipientUUIDs = recipientPlayers.stream().map(Entity::getUniqueId).toList();
Bukkit.getServer().getOnlinePlayers().stream()
.filter(onlinePlayer -> onlinePlayer.hasPermission(Config.SPYPERMISSION))
.filter(onlinePlayer -> !recipientUUIDs.contains(onlinePlayer.getUniqueId()))
.forEach(onlinePlayer -> onlinePlayer.sendRichMessage(Config.CHANNEL_SPY,
Placeholder.component("sender", player.name()),
Placeholder.parsed("channel", chatChannel.getChannelName()),
Placeholder.parsed("message", message)));
.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) {
@ -310,7 +262,7 @@ public class ChatHandler {
player.sendPluginMessage(plugin, Config.MESSAGECHANNEL, out.toByteArray());
}
public void sendChatChannelMessage(Player player, String chatChannelName, String channel, Component component, String ignored) {
public void sendChatChannelMessage(Player player, String chatChannelName, String channel, Component component) {
ByteArrayDataOutput out = ByteStreams.newDataOutput();
out.writeUTF(channel);
out.writeUTF(chatChannelName);
@ -323,9 +275,7 @@ public class ChatHandler {
private boolean isMuted(Player player, String message, String prefix) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
if (user == null) {
return false;
}
if (user == null) return false;
if (user.isMuted() || (ChatPlugin.getInstance().serverMuted() && !player.hasPermission("chat.bypass-server-muted"))) {
// if (Database.get().isPlayerMuted(player.getUniqueId(), null) || (ChatPlugin.getInstance().serverMuted() && !player.hasPermission("chat.bypass-server-muted"))) {
GalaxyUtility.sendBlockedNotification(prefix, player, Utility.parseMiniMessage(Utility.stripTokens(message)), "");
@ -336,12 +286,11 @@ public class ChatHandler {
public static Component itemComponent(ItemStack item) {
Component component = Component.text("[i]", NamedTextColor.AQUA);
if (item.getType().equals(Material.AIR)) {
if(item.getType().equals(Material.AIR))
return component.color(NamedTextColor.WHITE);
}
boolean dname = item.hasItemMeta() && item.getItemMeta().hasDisplayName();
if(dname) {
component = component.append(Objects.requireNonNull(item.getItemMeta().displayName()));
component = component.append(item.getItemMeta().displayName());
} else {
component = component.append(Component.text(materialToName(item.getType()), NamedTextColor.WHITE));
}
@ -363,12 +312,10 @@ public class ChatHandler {
int loc = sb.lastIndexOf(split);
char charLoc = sb.charAt(loc);
if (!(split.equalsIgnoreCase("of") || split.equalsIgnoreCase("and") ||
split.equalsIgnoreCase("with") || split.equalsIgnoreCase("on"))) {
split.equalsIgnoreCase("with") || split.equalsIgnoreCase("on")))
sb.setCharAt(loc, Character.toUpperCase(charLoc));
}
if (pos != splits.length - 1) {
if (pos != splits.length - 1)
sb.append(' ');
}
++pos;
}

85
galaxy/src/main/java/com/alttd/chat/listeners/ChatListener.java
View File

@ -5,19 +5,17 @@ import com.alttd.chat.config.Config;
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.objects.ChatFilter;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.ModifiableString;
import com.alttd.chat.objects.Toggleable;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.GalaxyUtility;
import com.alttd.chat.util.ServerName;
import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import io.papermc.paper.event.player.AsyncChatCommandDecorateEvent;
import io.papermc.paper.event.player.AsyncChatDecorateEvent;
import io.papermc.paper.event.player.AsyncChatEvent;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
@ -34,46 +32,35 @@ import org.jetbrains.annotations.NotNull;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class ChatListener implements Listener {
private final PlainTextComponentSerializer plainTextComponentSerializer = PlainTextComponentSerializer.plainText();
private final ChatLogHandler chatLogHandler;
public ChatListener(ChatLogHandler chatLogHandler) {
this.chatLogHandler = chatLogHandler;
}
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onChatCommandDecorate(AsyncChatCommandDecorateEvent event) {
if (event.player() == null) {
return;
}
if (event.player() == null) return;
Component formatComponent = Component.text("%message%");
ComponentLike message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
Component message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
}
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onChatDecorate(AsyncChatDecorateEvent event) {
if (event.player() == null) {
return;
}
if (event.player() == null) return;
Component formatComponent = Component.text("%message%");
ComponentLike message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
Component message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
}
private final Component mention = MiniMessage.miniMessage().deserialize(Config.MENTIONPLAYERTAG);
@EventHandler(ignoreCancelled = true)
public void onPlayerChat(AsyncChatEvent event) {
event.setCancelled(true); //Always cancel the event because we do not want to deal with Microsoft's stupid bans
@ -89,42 +76,25 @@ public class ChatListener implements Listener {
}
Player player = event.getPlayer();
UUID uuid = player.getUniqueId();
ComponentLike input = event.message().colorIfAbsent(NamedTextColor.WHITE);
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());
ModifiableString modifiableString = new ModifiableString(input.asComponent());
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 (!filterType.equals(FilterType.PUNISH)) {
ALogger.warn("Received another FilterType than punish when filtering chat and executing a filter action");
return;
}
ByteArrayDataOutput out = ByteStreams.newDataOutput();
out.writeUTF("punish");
out.writeUTF(player.getName());
out.writeUTF(uuid.toString());
out.writeUTF(modifiableString.string());
player.sendPluginMessage(ChatPlugin.getInstance(), Config.MESSAGECHANNEL, out.toByteArray());
})) {
if(!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "chat")) {
event.setCancelled(true);
GalaxyUtility.sendBlockedNotification("Language", player,
modifiableString.component(),
"");
chatLogHandler.addChatLog(uuid, ServerName.getServerName(), PlainTextComponentSerializer.plainText().serialize(input.asComponent()), 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);
@ -135,8 +105,7 @@ public class ChatListener implements Listener {
for (Player pingPlayer : playersToPing) {
pingPlayer.playSound(pingPlayer.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1);
}
chatLogHandler.addChatLog(uuid, ServerName.getServerName(), modifiableString.string(), false);
ALogger.info(PlainTextComponentSerializer.plainText().serialize(input.asComponent()));
ALogger.info(PlainTextComponentSerializer.plainText().serialize(input));
}
private void pingPlayers(Set<Player> playersToPing, ModifiableString modifiableString, Player player) {
@ -149,12 +118,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()
@ -164,26 +132,21 @@ 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);
}
}
}
}
public @NotNull ComponentLike render(@NotNull Player player, @NotNull Component message) {
public @NotNull Component render(@NotNull Player player, @NotNull Component message) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", user.getDisplayName()),
@ -197,7 +160,7 @@ public class ChatListener implements Listener {
return Utility.parseMiniMessage(Config.CHATFORMAT, placeholders);
}
private ComponentLike parseMessageContent(Player player, String rawMessage) {
private Component parseMessageContent(Player player, String rawMessage) {
TagResolver.Builder tagResolver = TagResolver.builder();
Utility.formattingPerms.forEach((perm, pair) -> {
@ -207,7 +170,7 @@ public class ChatListener implements Listener {
});
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(Utility.formatText(rawMessage));
Component component = miniMessage.deserialize(rawMessage);
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText(
TextReplacementConfig.builder()

55
galaxy/src/main/java/com/alttd/chat/listeners/PlayerListener.java
View File

@ -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);
}
}

125
galaxy/src/main/java/com/alttd/chat/listeners/PluginMessage.java
View File

@ -5,110 +5,106 @@ import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Party;
import com.alttd.chat.objects.PartyUser;
import com.alttd.chat.objects.channels.Channel;
import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.ServerName;
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.ComponentLike;
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;
}
ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
String subChannel = in.readUTF();
switch (subChannel) {
case "privatemessagein" -> {
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;
}
if (p != null) {
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
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)) {
if (!user.getReplyContinueTarget().equalsIgnoreCase(target))
user.setReplyTarget(target);
}
}
}
case "privatemessageout" -> {
UUID uuid = UUID.fromString(in.readUTF());
String target = in.readUTF();
Player player = Bukkit.getPlayer(uuid);
String message = in.readUTF();
UUID targetuuid = UUID.fromString(in.readUTF());
if (player == null) {
break;
}
case "privatemessageout": {
UUID uuid = UUID.fromString(in.readUTF());
String target = in.readUTF();
Player p = Bukkit.getPlayer(uuid);
String message = in.readUTF();
UUID targetuuid = UUID.fromString(in.readUTF());
if (p != null) {
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
if (isTargetNotIgnored(chatUser, targetuuid)) {
if (!chatUser.getIgnoredPlayers().contains(targetuuid)) {
chatUser.setReplyTarget(target);
player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
p.sendMessage(GsonComponentSerializer.gson().deserialize(message));
// ChatUser user = ChatUserManager.getChatUser(uuid);
// user.setReplyTarget(target);
}
}
case "globalchat" -> {
if (!ChatPlugin.getInstance().serverGlobalChatEnabled() || ChatPlugin.getInstance().serverMuted()) {
break;
}
case "globalchat": {
if (!ChatPlugin.getInstance().serverGlobalChatEnabled() || ChatPlugin.getInstance().serverMuted()) break;
UUID uuid = UUID.fromString(in.readUTF());
String message = in.readUTF();
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));
}
});
break;
}
case "ignore" -> {
case "ignore": {
ChatUser chatUser = ChatUserManager.getChatUser(UUID.fromString(in.readUTF()));
UUID targetUUID = UUID.fromString(in.readUTF());
if(!chatUser.getIgnoredPlayers().contains(targetUUID)) {
chatUser.addIgnoredPlayers(targetUUID);
}
}
case "unignore" -> {
ChatUser chatUser = ChatUserManager.getChatUser(UUID.fromString(in.readUTF()));
chatUser.removeIgnoredPlayers(UUID.fromString(in.readUTF()));
}
case "chatchannel" -> {
if (ChatPlugin.getInstance().serverMuted()) {
break;
}
case "unignore": {
ChatUser chatUser = ChatUserManager.getChatUser(UUID.fromString(in.readUTF()));
chatUser.removeIgnoredPlayers(UUID.fromString(in.readUTF()));
break;
}
case "chatchannel": {
if (ChatPlugin.getInstance().serverMuted()) break;
chatChannel(in);
break;
}
case "tmppartyupdate" -> {
case "tmppartyupdate" : {
int id = Integer.parseInt(in.readUTF());
new BukkitRunnable() {
@Override
@ -116,8 +112,9 @@ public class PluginMessage implements PluginMessageListener {
Queries.loadPartyUsers(id);
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
break;
}
case "partylogin" -> {
case "partylogin": {
int id = Integer.parseInt(in.readUTF());
Party party = PartyManager.getParty(id);
if (party == null) {
@ -130,19 +127,18 @@ public class PluginMessage implements PluginMessageListener {
public void run() {
PartyUser user = party.getPartyUser(uuid);
if(user != null) {
ComponentLike component = Utility.parseMiniMessage(
"<dark_aqua>* " + user.getPlayerName() + " logged in to Altitude.");
Component component = Utility.parseMiniMessage("<dark_aqua>* " + user.getPlayerName() + " logged in to Altitude.");
Bukkit.getOnlinePlayers().stream()
.filter(p -> party.getPartyUsersUuid().contains(p.getUniqueId()))
.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers()
.contains(uuid))
.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers().contains(uuid))
.forEach(p -> p.sendMessage(component));
}
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
break;
}
case "partylogout" -> {
case "partylogout": {
int id = Integer.parseInt(in.readUTF());
Party party = PartyManager.getParty(id);
if (party == null) {
@ -155,30 +151,29 @@ public class PluginMessage implements PluginMessageListener {
public void run() {
PartyUser user = party.getPartyUser(uuid);
if(user != null) {
ComponentLike component = Utility.parseMiniMessage(
"<dark_aqua>* " + user.getPlayerName() + " logged out of Altitude.");
Component component = Utility.parseMiniMessage("<dark_aqua>* " + user.getPlayerName() + " logged out of Altitude.");
Bukkit.getOnlinePlayers().stream()
.filter(p -> party.getPartyUsersUuid().contains(p.getUniqueId()))
.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers()
.contains(uuid))
.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers().contains(uuid))
.forEach(p -> p.sendMessage(component));
}
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
break;
}
case "reloadconfig" -> ChatPlugin.getInstance().reloadConfig();
case "chatpunishments" -> {
case "reloadconfig":
ChatPlugin.getInstance().ReloadConfig();
break;
case "chatpunishments":
UUID uuid = UUID.fromString(in.readUTF());
boolean mute = in.readBoolean();
ChatUser user = ChatUserManager.getChatUser(uuid);
if (user == null) {
return;
}
if (user == null) return;
user.setMuted(mute);
}
default -> {
}
break;
default:
break;
}
}
@ -190,15 +185,15 @@ public class PluginMessage implements PluginMessageListener {
chatChannel = (CustomChannel) Channel.getChatChannel(in.readUTF());
uuid = UUID.fromString(in.readUTF());
component = GsonComponentSerializer.gson().deserialize(in.readUTF());
} catch (Exception e) {
ALogger.error("Failed to read ChatChannel message.", e);
} catch (Exception e) { //Idk the exception for reading too far into in.readUTF()
e.printStackTrace();
}
if (chatChannel == null) {
ALogger.warn("Received ChatChannel message for non existent channel.");
return;
}
if (!chatChannel.getServers().contains(ServerName.getServerName())) {
if (!chatChannel.getServers().contains(Bukkit.getServerName())) {
ALogger.warn("Received ChatChannel message for the wrong server.");
return;
}
@ -215,22 +210,10 @@ public class PluginMessage implements PluginMessageListener {
public void run() {
Bukkit.getOnlinePlayers().stream()
.filter(p -> p.hasPermission(finalChatChannel.getPermission()))
.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers()
.contains(finalUuid))
.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers().contains(finalUuid))
.forEach(p -> p.sendMessage(finalComponent));
}
}.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");
}
}

27
galaxy/src/main/java/com/alttd/chat/listeners/ShutdownListener.java
View File

@ -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();
}
}

118
galaxy/src/main/java/com/alttd/chat/nicknames/NickUtilities.java
View File

@ -4,21 +4,100 @@ import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries;
import com.alttd.chat.objects.Nick;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.TextComponent;
import net.kyori.adventure.text.format.TextColor;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.kyori.adventure.text.serializer.legacy.LegacyFormat;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import java.awt.*;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.UUID;
public class NickUtilities {
public class NickUtilities
{
public static String stringRegen;
public static String applyColor(String message) {
ChatColor hexColor1 = null;
ChatColor hexColor2;
StringBuilder stringBuilder = new StringBuilder();
message = ChatColor.translateAlternateColorCodes('&', message);
boolean startsWithColor = false;
boolean lastColorMatters = false;
if (message.matches(".*" + NickUtilities.stringRegen + ".*")) {
String[] split = message.split(NickUtilities.stringRegen);
ArrayList<String> list = new ArrayList<>();
int nextIndex = 0;
if (message.indexOf("}") <= 11) {
startsWithColor = true;
list.add(message.substring(0, message.indexOf("}") + 1));
}
for (String s : split) {
nextIndex += s.length();
int tmp = message.indexOf("}", nextIndex);
if (tmp < message.length() && tmp>=0) {
list.add(message.substring(nextIndex, tmp + 1));
nextIndex = tmp + 1;
}
}
int i;
boolean firstLoop = true;
if (startsWithColor) {
i = -1;
} else {
i = 0;
stringBuilder.append(split[i]);
}
for (String s : list) {
boolean lesser = s.contains("<");
boolean bigger = s.contains(">");
if (bigger && lesser) {
hexColor2 = ChatColor.of(s.substring(1, s.length() - 3));
} else if (bigger || lesser) {
hexColor2 = ChatColor.of(s.substring(1, s.length() - 2));
} else {
hexColor2 = ChatColor.of(s.substring(1, s.length() -1));
}
if (firstLoop) {
lastColorMatters = bigger;
hexColor1 = hexColor2;
firstLoop = false;
i++;
continue;
}
if (lesser && lastColorMatters) {
stringBuilder.append(hexGradient(hexColor1.getColor(), hexColor2.getColor(), split[i]));
} else {
stringBuilder.append(hexColor1).append(split[i]);
}
hexColor1 = hexColor2;
lastColorMatters = bigger;
i++;
}
if (split.length > i){
stringBuilder.append(hexColor1).append(split[i]);
}
}
return stringBuilder.length()==0 ? message : stringBuilder.toString();
}
public static String removeAllColors(String string) {
for (final String colorCodes : Config.NICK_ALLOWED_COLOR_CODESLIST) {
@ -32,6 +111,29 @@ public class NickUtilities {
NickUtilities.stringRegen = "\\{#[A-Fa-f0-9]{6}(<)?(>)?}";
}
public static String hexGradient(Color color1, Color color2, String text){
double r = color1.getRed();
double g = color1.getGreen();
double b = color1.getBlue();
double rDifference = (color1.getRed() - color2.getRed()) / ((double) text.length() - 1);
double gDifference = (color1.getGreen() - color2.getGreen()) / ((double) text.length() - 1);
double bDifference = (color1.getBlue() - color2.getBlue()) / ((double) text.length() - 1);
StringBuilder stringBuilder = new StringBuilder();
char[] chars = text.toCharArray();
for (int i = 0; i < text.length(); i++) {
if (i > 0) {
r = r - rDifference;
g = g - gDifference;
b = b - bDifference;
}
stringBuilder.append(ChatColor.of(new Color((int) r, (int) g, (int) b))).append(chars[i]);
}
return stringBuilder.toString();
}
public static void updateCache() {
if (!Nicknames.getInstance().nickCacheUpdate.isEmpty()){
Nicknames.getInstance().nickCacheUpdate.forEach(uuid ->{
@ -47,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;
}
@ -81,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;
}
}
@ -111,7 +213,7 @@ public class NickUtilities {
try {
msgout.writeUTF(uniqueId.toString());
} catch (IOException exception){
ALogger.error("Failed to write UUID to byte array", exception);
exception.printStackTrace();
return;
}
byte[] bytes = msgbytes.toByteArray();

117
galaxy/src/main/java/com/alttd/chat/nicknames/Nicknames.java
View File

@ -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;
@ -8,10 +10,10 @@ import com.alttd.chat.events.NickEvent;
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.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;
@ -22,6 +24,7 @@ import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
@ -47,7 +50,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String label, String[] args) {
if (sender instanceof Player player) {
if (args.length == 0) {
sender.sendRichMessage(helpMessage(sender, HelpType.ALL));
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL)));
return true;
}
switch (args[0].toLowerCase()) {
@ -60,10 +63,10 @@ public class Nicknames implements CommandExecutor, TabCompleter {
if (offlinePlayer.isOnline() || offlinePlayer.hasPlayedBefore()) {
handleNick(player, offlinePlayer, args[2]);
} else {
sender.sendRichMessage(helpMessage(sender, HelpType.SET_OTHERS));
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.SET_OTHERS)));
}
} else if (args.length > 3) {
sender.sendRichMessage(helpMessage(sender, HelpType.SET_SELF, HelpType.SET_OTHERS));
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.SET_SELF, HelpType.SET_OTHERS)));
}
break;
case "review":
@ -72,7 +75,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
ChatPlugin.getInstance().getServer().getPluginManager().registerEvents(nicknamesGui, ChatPlugin.getInstance());
nicknamesGui.openInventory(player);
} else {
sender.sendRichMessage(helpMessage(sender, HelpType.REVIEW));
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.REVIEW)));
}
break;
case "request":
@ -84,7 +87,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
} else {
sender.sendRichMessage(helpMessage(sender, HelpType.REQUEST));
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.REQUEST)));
}
break;
case "try":
@ -92,17 +95,16 @@ public class Nicknames implements CommandExecutor, TabCompleter {
LuckPerms api = ChatAPI.get().getLuckPerms();
if (api != null) {
if (NickUtilities.validNick(player, player, args[1])) {
sender.sendRichMessage(Config.NICK_TRYOUT,
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_TRYOUT,
Placeholder.component("prefix", Utility.applyColor(api.getUserManager().getUser(player.getUniqueId())
.getCachedData().getMetaData().getPrefix())), // TODO pull this from chatuser?
Placeholder.component("nick", Utility.applyColor(args[1])),
Placeholder.unparsed("nickrequest", args[1]));
Placeholder.component("nick", Utility.applyColor(args[1]))));
}
} else {
sender.sendRichMessage(Config.NICK_NO_LUCKPERMS);
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_NO_LUCKPERMS));
}
} else {
sender.sendRichMessage(helpMessage(sender, HelpType.TRY));
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.TRY)));
}
break;
case "current":
@ -112,15 +114,15 @@ 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":
sender.sendRichMessage(helpMessage(sender, HelpType.ALL)
+ "For more info on nicknames and how to use rgb colors go to: <aqua>https://alttd.com/nicknames<white>");
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL)
+ "For more info on nicknames and how to use rgb colors go to: <aqua>https://alttd.com/nicknames<white>"));
break;
default:
sender.sendRichMessage(helpMessage(sender, HelpType.ALL));
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL)));
}
} else {
sender.sendMessage("Console commands are disabled.");
@ -131,9 +133,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
@Override
public List<String> onTabComplete(CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
List<String> completions = new ArrayList<>();
if (!sender.hasPermission("chat.command.nick")) {
return completions;
}
if (!sender.hasPermission("chat.command.nick")) return completions;
if (args.length == 1) {
List<String> choices = new ArrayList<>();
@ -193,15 +193,15 @@ public class Nicknames implements CommandExecutor, TabCompleter {
long waitTime = Config.NICK_WAIT_TIME;
if (timeSinceLastChange > waitTime || player.hasPermission("chat.command.nick.bypasswaittime")) {
if (nick.hasRequest()) {
player.sendRichMessage(Config.NICK_REQUEST_PLACED,
player.sendMessage(Utility.parseMiniMessage(Config.NICK_REQUEST_PLACED,
Placeholder.component("oldrequestednick", Utility.applyColor(nick.getNewNick())),
Placeholder.component("newrequestednick", Utility.applyColor(nickName)));
Placeholder.component("newrequestednick", Utility.applyColor(nickName))));
}
nick.setNewNick(nickName);
nick.setRequestedDate(new Date().getTime());
} else {
player.sendRichMessage(Config.NICK_TOO_SOON,
Placeholder.unparsed("time", formatTime((timeSinceLastChange - waitTime) * -1)));
player.sendMessage(Utility.parseMiniMessage(Config.NICK_TOO_SOON,
Placeholder.unparsed("time", formatTime((timeSinceLastChange-waitTime)*-1))));
return;
}
} else {
@ -209,8 +209,8 @@ public class Nicknames implements CommandExecutor, TabCompleter {
}
Queries.newNicknameRequest(uniqueId, nickName);
bungeeMessageRequest(player);
player.sendRichMessage(Config.NICK_REQUESTED,
Placeholder.component("nick", Utility.applyColor(nickName)));
player.sendMessage(Utility.parseMiniMessage(Config.NICK_REQUESTED,
Placeholder.component("nick", Utility.applyColor(nickName))));
}
private void bungeeMessageRequest(Player player) {
@ -227,7 +227,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
try {
msgout.writeUTF(uniqueId.toString());
} catch (IOException exception) {
ALogger.error("Failed to write UUID to ByteArrayOutputStream", exception);
exception.printStackTrace();
return;
}
byte[] bytes = msgbytes.toByteArray();
@ -264,22 +264,22 @@ public class Nicknames implements CommandExecutor, TabCompleter {
try {
if (target.isOnline()) {
resetNick(Objects.requireNonNull(target.getPlayer()));
resetNick(target.getPlayer());
}
Queries.removePlayerFromDataBase(target.getUniqueId());
NickCache.remove(target.getUniqueId());
nickCacheUpdate.add(target.getUniqueId());
} catch (SQLException e) {
ALogger.error("Failed to remove nickname from database", e);
e.printStackTrace();
}
if (!sender.equals(target)) {
sender.sendRichMessage(Config.NICK_RESET_OTHERS,
Placeholder.unparsed("player", Objects.requireNonNull(target.getName())));
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_RESET_OTHERS,
Placeholder.unparsed("player", target.getName())));
}
if (target.isOnline() && target.getPlayer() != null) {
target.getPlayer().sendRichMessage(Config.NICK_RESET);
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_RESET));
}
NickEvent nickEvent = new NickEvent(sender.getName(), target.getName(), null, NickEvent.NickEventType.RESET);
@ -307,19 +307,17 @@ public class Nicknames implements CommandExecutor, TabCompleter {
if (!sender.equals(target)) {
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_CHANGED_OTHERS,
Placeholder.unparsed("targetplayer", Objects.requireNonNull(target.getName())),
Placeholder.unparsed("targetplayer", target.getName()),
Placeholder.unparsed("nickname", nickName)));
if (target.isOnline()) {
Objects.requireNonNull(target.getPlayer())
.sendRichMessage(Config.NICK_TARGET_NICK_CHANGE,
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_TARGET_NICK_CHANGE,
Placeholder.unparsed("nickname", getNick(target.getPlayer())),
Placeholder.unparsed("sendernick", getNick(sender)),
Placeholder.unparsed("player", target.getName()));
Placeholder.unparsed("player", target.getName())));
}
} else if (target.isOnline()) {
Objects.requireNonNull(target.getPlayer())
.sendRichMessage(Config.NICK_CHANGED,
Placeholder.unparsed("nickname", getNick(target.getPlayer())));
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_CHANGED,
Placeholder.unparsed("nickname", getNick(target.getPlayer()))));
}
}
}
@ -357,10 +355,8 @@ public class Nicknames implements CommandExecutor, TabCompleter {
break;
case REQUEST:
if (sender.hasPermission("chat.command.nick.request")) {
message.append("""
<gold>/nick request <nickname><white> - Requests a username to be reviewed by staff.
<gray>Try using <dark_gray>/nick try <nickname><gray> to see if you like the name, you can only change it once per day!
""");
message.append("<gold>/nick request <nickname><white> - Requests a username to be reviewed by staff.\n" +
" <gray>Try using <dark_gray>/nick try <nickname><gray> to see if you like the name, you can only change it once per day!\n");
}
break;
case REVIEW:
@ -387,8 +383,8 @@ public class Nicknames implements CommandExecutor, TabCompleter {
public void resetNick(final Player player) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
user.setDisplayName(player.getName());
player.displayName(user.getDisplayName().asComponent());
// updateCMIUser(player, null);
player.displayName(user.getDisplayName());
updateCMIUser(player, null);
}
public String getNick(final Player player) {
@ -397,13 +393,42 @@ public class Nicknames implements CommandExecutor, TabCompleter {
}
public void setNick(final Player player, final String nickName) {
if (player == null) {
if (player == null)
return;
}
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
user.setDisplayName(nickName);
player.displayName(user.getDisplayName().asComponent());
player.displayName(user.getDisplayName());
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();
}
private Boolean isCMIEnabled = null;
private Boolean isCMIEnabled() {
if (!(isCMIEnabled == null))
return isCMIEnabled;
Plugin plugin = Bukkit.getPluginManager().getPlugin("CMI");
if (plugin != null && plugin.isEnabled())
return isCMIEnabled = true;
return isCMIEnabled = false;
}
public static Nicknames getInstance() {

30
galaxy/src/main/java/com/alttd/chat/nicknames/NicknamesEvents.java
View File

@ -1,15 +1,17 @@
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.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.ComponentLike;
import net.kyori.adventure.text.event.ClickEvent;
import net.kyori.adventure.text.event.HoverEvent;
import net.kyori.adventure.text.minimessage.MiniMessage;
@ -31,6 +33,7 @@ import java.util.UUID;
public class NicknamesEvents implements Listener, PluginMessageListener {
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onPlayerJoin(PlayerJoinEvent e) {
@ -76,8 +79,8 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
}
if (i > 0) {
player.sendRichMessage(Config.NICK_REQUESTS_ON_LOGIN,
Placeholder.unparsed("amount", String.valueOf(i)));
player.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_REQUESTS_ON_LOGIN,
Placeholder.unparsed("amount", String.valueOf(i))));
}
}
}
@ -111,14 +114,14 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
name = offlinePlayer.getName() == null ? playerUUID.toString() : offlinePlayer.getName();
} catch (Exception e) {
ALogger.error("Failed to read plugin message", e);
e.printStackTrace();
return;
}
MiniMessage miniMessage = MiniMessage.miniMessage();
switch (subChannel) {
case "NickNameRequest":
ComponentLike component = miniMessage.deserialize(Config.NICK_REQUEST_NEW, Placeholder.parsed("player", name))
Component component = miniMessage.deserialize(Config.NICK_REQUEST_NEW, Placeholder.parsed("player", name))
.clickEvent(ClickEvent.clickEvent(ClickEvent.Action.RUN_COMMAND,
"/nick review"))
.hoverEvent(HoverEvent.hoverEvent(HoverEvent.Action.SHOW_TEXT,
@ -139,8 +142,7 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
}
break;
case "NickNameAccepted":
ComponentLike deserialize = Utility.parseMiniMessage("<green><name>'s nickname was accepted!",
Component deserialize = miniMessage.deserialize("<green><name>'s nickname was accepted!",
Placeholder.unparsed("name", name));
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("chat.command.nick.review")) {
@ -155,8 +157,8 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
Player target = Bukkit.getPlayer(playerUUID);
if (target != null && nick != null && nick.getCurrentNick() != null) {
Nicknames.getInstance().setNick(target, nick.getCurrentNick());
target.sendRichMessage(Config.NICK_CHANGED,
Placeholder.unparsed("nickname", nick.getCurrentNick()));
target.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_CHANGED,
Placeholder.unparsed("nickname", nick.getCurrentNick())));
}
}
break;
@ -183,11 +185,9 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
if (offlinePlayer.isOnline()) {
Player target = Bukkit.getPlayer(playerUUID);
if (target == null) {
break;
}
target.sendRichMessage(Config.NICK_NOT_CHANGED,
Placeholder.unparsed("nickname", nick.getCurrentNick()));
if (target == null) break;
target.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_NOT_CHANGED,
Placeholder.unparsed("nickname", nick.getCurrentNick())));
}
break;
}

73
galaxy/src/main/java/com/alttd/chat/nicknames/NicknamesGui.java
View File

@ -7,7 +7,6 @@ import com.alttd.chat.events.NickEvent;
import com.alttd.chat.objects.Nick;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
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;
@ -41,7 +40,7 @@ public class NicknamesGui implements Listener {
public NicknamesGui() {
// Create a new inventory, with no owner (as this isn't a real inventory)
inv = Bukkit.createInventory(null, 36, Utility.parseMiniMessage("Nicknames GUI").asComponent());
inv = Bukkit.createInventory(null, 36, Utility.parseMiniMessage("Nicknames GUI"));
// Put the items into the inventory
currentPage = 1;
@ -93,11 +92,10 @@ public class NicknamesGui implements Listener {
meta.setOwningPlayer(offlinePlayer);
String name = offlinePlayer.getName();
if (name == null) {
if (name == null)
meta.displayName(miniMessage.deserialize("UNKNOWN PLAYER NAME"));
} else {
else
meta.displayName(miniMessage.deserialize(offlinePlayer.getName()));
}
TagResolver resolver = TagResolver.resolver(
Placeholder.component("newnick", Utility.applyColor(nick.getNewNick())),
@ -134,42 +132,30 @@ public class NicknamesGui implements Listener {
// Check for clicks on items
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onInventoryClick(InventoryClickEvent e) {
if (e.getInventory() != inv) {
return;
}
if (e.getInventory() != inv) return;
e.setCancelled(true);
final ItemStack clickedItem = e.getCurrentItem();
if (clickedItem == null || clickedItem.getType() == Material.AIR) {
return;
}
if (clickedItem == null || clickedItem.getType() == Material.AIR) return;
final Player p = (Player) e.getWhoClicked();
if (clickedItem.getType().equals(Material.PAPER)) {
Component component = clickedItem.getItemMeta().displayName();
if (component == null) {
throw new IllegalStateException("Nicknames GUI: Item with no display name clicked!");
}
String serialize = PlainTextComponentSerializer.plainText().serialize(component);
String serialize = PlainTextComponentSerializer.plainText().serialize(clickedItem.getItemMeta().displayName());
if (serialize.equals("Next Page")) {
setItems(currentPage + 1);
}
} else if (clickedItem.getType().equals(Material.PLAYER_HEAD)) {
ItemMeta itemMeta = clickedItem.getItemMeta();
if (itemMeta == null) {
return;
}
SkullMeta meta = (SkullMeta) itemMeta;
SkullMeta meta = (SkullMeta) clickedItem.getItemMeta();
if (meta.hasEnchants()) {
return;
}
OfflinePlayer owningPlayer = meta.getOwningPlayer();
if (owningPlayer == null) {
p.sendRichMessage(Config.NICK_USER_NOT_FOUND);
p.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_USER_NOT_FOUND));
return;
}
@ -185,15 +171,10 @@ public class NicknamesGui implements Listener {
} else {
nick = Queries.getNick(uniqueId);
}
Component itemDisplayName = itemMeta.displayName();
if (itemDisplayName == null) {
return;
}
if (nick == null || !nick.hasRequest()) {
p.sendRichMessage(Config.NICK_ALREADY_HANDLED,
Placeholder.component("targetplayer", itemDisplayName))
;
p.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_ALREADY_HANDLED,
Placeholder.component("targetplayer", clickedItem.getItemMeta().displayName())));
return;
}
@ -206,18 +187,20 @@ public class NicknamesGui implements Listener {
new BukkitRunnable() {
@Override
public void run() {
NickEvent nickEvent = new NickEvent(e.getWhoClicked().getName(), itemMeta.getDisplayName(), newNick, NickEvent.NickEventType.ACCEPTED);
NickEvent nickEvent = new NickEvent(e.getWhoClicked().getName(), clickedItem.getItemMeta().getDisplayName(), newNick, NickEvent.NickEventType.ACCEPTED);
nickEvent.callEvent();
}
}.runTask(ChatPlugin.getInstance());
p.sendRichMessage(Config.NICK_ACCEPTED,
Placeholder.component("targetplayer", itemDisplayName),
p.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_ACCEPTED,
Placeholder.component("targetplayer", clickedItem.getItemMeta().displayName()),
Placeholder.component("newnick", Utility.applyColor(nick.getNewNick())),
Placeholder.component("oldnick", Utility.applyColor(nick.getCurrentNick() == null ? itemMeta.getDisplayName() : nick.getCurrentNick())));
Placeholder.component("oldnick", Utility.applyColor(nick.getCurrentNick() == null ? clickedItem.getItemMeta().getDisplayName() : nick.getCurrentNick()))));
if (owningPlayer.isOnline() && owningPlayer.getPlayer() != null) {
Nicknames.getInstance().setNick(owningPlayer.getPlayer(), nick.getNewNick());
// owningPlayer.getPlayer().sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_CHANGED // This message is also send when the plugin message is received
// .replace("%nickname%", nick.getNewNick())));
}
NickUtilities.bungeeMessageHandled(uniqueId, e.getWhoClicked().getServer().getPlayer(e.getWhoClicked().getName()), "Accepted");
@ -231,16 +214,18 @@ public class NicknamesGui implements Listener {
ItemStack itemStack = new ItemStack(Material.SKELETON_SKULL);
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.displayName(itemMeta.displayName());
itemMeta.displayName(clickedItem.getItemMeta().displayName());
itemMeta.lore(clickedItem.lore());
itemStack.setItemMeta(itemMeta);
e.getInventory().setItem(e.getSlot(), itemStack);
p.updateInventory();
} else {
p.sendRichMessage(Config.NICK_PLAYER_NOT_ONLINE, Placeholder.component("player", itemDisplayName));
p.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_PLAYER_NOT_ONLINE,
Placeholder.component("playerName", clickedItem.getItemMeta().displayName())));
}
} else if (e.isRightClick()) {
Component displayName = clickedItem.getItemMeta().displayName();
if (owningPlayer.hasPlayedBefore()) {
Queries.denyNewNickname(uniqueId);
@ -249,7 +234,7 @@ public class NicknamesGui implements Listener {
new BukkitRunnable() {
@Override
public void run() {
NickEvent nickEvent = new NickEvent(e.getWhoClicked().getName(), itemMeta.getDisplayName(), newNick, NickEvent.NickEventType.DENIED);
NickEvent nickEvent = new NickEvent(e.getWhoClicked().getName(), clickedItem.getItemMeta().getDisplayName(), newNick, NickEvent.NickEventType.DENIED);
nickEvent.callEvent();
}
}.runTask(ChatPlugin.getInstance());
@ -270,11 +255,11 @@ public class NicknamesGui implements Listener {
if (owningPlayer.isOnline() && owningPlayer.getPlayer() != null) {
Nicknames.getInstance().setNick(owningPlayer.getPlayer(), nick.getCurrentNick() == null ? owningPlayer.getName() : nick.getCurrentNick());
owningPlayer.getPlayer().sendRichMessage(Config.NICK_NOT_CHANGED);
owningPlayer.getPlayer().sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_NOT_CHANGED));
}
NickUtilities.bungeeMessageHandled(uniqueId, e.getWhoClicked().getServer().getPlayer(e.getWhoClicked().getName()), "Denied");
final ComponentLike messageDenied = MiniMessage.miniMessage().deserialize("<red><name>'s nickname was denied!",
final Component messageDenied = MiniMessage.miniMessage().deserialize("<red><name>'s nickname was denied!",
Placeholder.unparsed("name", owningPlayer.getName()));
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("chat.command.nick.review")) {
@ -282,19 +267,19 @@ public class NicknamesGui implements Listener {
}
});
ItemStack itemStack = new ItemStack(Material.SKELETON_SKULL);
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.displayName(itemDisplayName);
itemMeta.displayName(displayName);
itemMeta.lore(clickedItem.lore());
itemStack.setItemMeta(itemMeta);
e.getInventory().setItem(e.getSlot(), itemStack);
p.updateInventory();
} else {
if (itemDisplayName == null) {
p.sendRichMessage(Config.NICK_PLAYER_NOT_ONLINE, Placeholder.parsed("player", "UNKNOWN PLAYER NAME"));
} else {
p.sendRichMessage(Config.NICK_PLAYER_NOT_ONLINE, Placeholder.component("player", itemDisplayName));
}
if (displayName == null)
p.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_PLAYER_NOT_ONLINE, Placeholder.parsed("playerName", "UNKNOWN PLAYER NAME")));
else
p.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_PLAYER_NOT_ONLINE, Placeholder.component("playerName", displayName)));
}
}
}

23
galaxy/src/main/java/com/alttd/chat/requests/NickNameRequest.java Normal file
View File

@ -0,0 +1,23 @@
package com.alttd.chat.requests;
import java.util.UUID;
public class NickNameRequest extends Request {
public NickNameRequest(UUID requester, String request) {
super(requester, request);
this.requestType = RequestType.NICKNAME;
}
public NickNameRequest(UUID requester, String request, boolean completed, UUID completedBy, long dateRequested, long dateCompleted) {
super(requester, request, completed, completedBy, dateRequested, dateCompleted);
this.requestType = RequestType.NICKNAME;
}
@Override
public boolean processRequest(UUID processor) {
return false;
}
}

24
galaxy/src/main/java/com/alttd/chat/requests/PrefixRequest.java Normal file
View File

@ -0,0 +1,24 @@
package com.alttd.chat.requests;
import java.util.UUID;
public class PrefixRequest extends Request{
public PrefixRequest(UUID requester, String request) {
super(requester, request);
this.requestType = RequestType.PREFIX;
}
public PrefixRequest(UUID requester, String request, boolean completed, UUID completedBy, long dateRequested, long dateCompleted) {
super(requester, request, completed, completedBy, dateRequested, dateCompleted);
this.requestType = RequestType.NICKNAME;
}
@Override
public boolean processRequest(UUID processor) {
return false;
}
}

69
galaxy/src/main/java/com/alttd/chat/requests/Request.java Normal file
View File

@ -0,0 +1,69 @@
package com.alttd.chat.requests;
import org.bukkit.Bukkit;
import java.util.Date;
import java.util.UUID;
public abstract class Request {
protected UUID requester;
protected RequestType requestType;
protected String serverName;
protected String request;
protected boolean completed;
protected UUID completedBy;
protected long dateRequested;
protected long dateCompleted;
Request(UUID requester, String request) {
this.requester = requester;
this.request = request;
this.serverName = Bukkit.getServerName();
this.dateRequested = new Date().getTime();
saveRequest();
}
Request(UUID requester, String request, boolean completed, UUID completedBy, long dateRequested, long dateCompleted) {
this.requester = requester;
this.request = request;
this.completed = completed;
this.completedBy = completedBy;
this.dateRequested = dateRequested;
this.dateCompleted = dateCompleted;
}
public static Request of(UUID requester, RequestType requestType, String request) {
return switch (requestType) {
case PREFIX -> new PrefixRequest(requester, request);
case NICKNAME -> new NickNameRequest(requester, request);
};
}
public static Request load(UUID requester, RequestType requestType, String request, boolean completed, UUID completedBy, long dateRequested, long dateCompleted) {
return switch (requestType) {
case PREFIX -> new PrefixRequest(requester, request, completed, completedBy, dateRequested, dateCompleted);
case NICKNAME -> new NickNameRequest(requester, request, completed, completedBy, dateRequested, dateCompleted);
};
}
public boolean processRequest(UUID completedBy) {
completeRequest(completedBy);
return true;
}
public boolean isCompleted() {
return completed;
}
void completeRequest(UUID completedBy) {
this.completed = true;
this.completedBy = completedBy;
this.dateCompleted = new Date().getTime();
saveRequest();
}
public void saveRequest() {
// upsert into database
}
}

61
galaxy/src/main/java/com/alttd/chat/requests/RequestHandler.java Normal file
View File

@ -0,0 +1,61 @@
package com.alttd.chat.requests;
import com.alttd.chat.config.Config;
import com.alttd.chat.database.DatabaseConnection;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
public class RequestHandler {
private final List<Request> requests;
public RequestHandler() {
requests = new ArrayList<>();
}
public boolean addRequest(Request request) {
return requests.add(request);
}
public boolean removeRequest(Request request) {
return requests.remove(request);
}
public List<Request> getRequests() {
return requests;
}
public void loadRequests() {
long time = new Date().getTime() - Config.NICK_WAIT_TIME;
// Load all requests that have not been completed yet
String query = "SELECT * FROM requests WHERE completed=false and (datechanged = 0 or datechanged > " + time + ")";
try {
Connection connection = DatabaseConnection.getConnection();
ResultSet resultSet = connection.prepareStatement(query).executeQuery();
while (resultSet.next()) {
UUID requester = UUID.fromString(resultSet.getString("requester"));
RequestType requestType = RequestType.valueOf(resultSet.getString("requesttype"));
String requestString = resultSet.getString("request");
boolean completed = resultSet.getBoolean("completed");
UUID completedby = UUID.fromString(resultSet.getString("completedby"));
long dateRequested = resultSet.getLong("daterequested");
long dateCompleted = resultSet.getLong("datecompleted");
Request request = Request.load(requester, requestType, requestString, completed, completedby, dateRequested, dateCompleted);
addRequest(request);
}
} catch (SQLException exception) {
exception.printStackTrace();
}
}
}

8
galaxy/src/main/java/com/alttd/chat/requests/RequestType.java Normal file
View File

@ -0,0 +1,8 @@
package com.alttd.chat.requests;
public enum RequestType {
NICKNAME,
PREFIX
}

22
galaxy/src/main/java/com/alttd/chat/requests/RequestsGui.java Normal file
View File

@ -0,0 +1,22 @@
package com.alttd.chat.requests;
import org.bukkit.Bukkit;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.jetbrains.annotations.NotNull;
public class RequestsGui implements InventoryHolder {
private final Inventory inventory;
private final int inventorySize = 54;
RequestsGui() {
inventory = Bukkit.createInventory(this, inventorySize, "A title");
}
@Override
public @NotNull Inventory getInventory() {
return inventory;
}
}

33
galaxy/src/main/java/com/alttd/chat/util/GalaxyUtility.java
View File

@ -2,9 +2,12 @@ package com.alttd.chat.util;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.RegexManager;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.TextDecoration;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
@ -13,22 +16,40 @@ import java.util.List;
public class GalaxyUtility {
public static void sendBlockedNotification(String prefix, Player player, ComponentLike input, String target) {
public static void sendBlockedNotification(String prefix, Player player, String input, String target) {
TagResolver placeholders = TagResolver.resolver(
Placeholder.parsed("prefix", prefix),
Placeholder.parsed("displayname", Utility.getDisplayName(player.getUniqueId(), player.getName())),
Placeholder.parsed("target", (target.isEmpty() ? "tried to say:" : "-> " + target + ":")),
Placeholder.component("input", input)
Placeholder.parsed("input", input)
);
ComponentLike blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, placeholders);
Component blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, placeholders);
Bukkit.getOnlinePlayers().forEach(a ->{
if (a.hasPermission("chat.alert-blocked")) {
a.sendMessage(blockedNotification);
}
});
player.sendRichMessage("<red>The language you used in your message is not allowed, " +
"this constitutes as your only warning. Any further attempts at bypassing the filter will result in staff intervention.</red>");
player.sendMessage(Utility.parseMiniMessage("<red>The language you used in your message is not allowed, " +
"this constitutes as your only warning. Any further attempts at bypassing the filter will result in staff intervention.</red>"));
}
public static void sendBlockedNotification(String prefix, Player player, Component input, String target) {
TagResolver placeholders = TagResolver.resolver(
Placeholder.parsed("prefix", prefix),
Placeholder.parsed("displayname", Utility.getDisplayName(player.getUniqueId(), player.getName())),
Placeholder.parsed("target", (target.isEmpty() ? "tried to say:" : "-> " + target + ":")),
Placeholder.component("input", input)
);
Component blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, placeholders);
Bukkit.getOnlinePlayers().forEach(a ->{
if (a.hasPermission("chat.alert-blocked")) {
a.sendMessage(blockedNotification);
}
});
player.sendMessage(Utility.parseMiniMessage("<red>The language you used in your message is not allowed, " +
"this constitutes as your only warning. Any further attempts at bypassing the filter will result in staff intervention.</red>"));
}
public static void addAdditionalChatCompletions(Player player) {

41
galaxy/src/main/java/com/alttd/chat/util/ServerName.java
View File

@ -1,41 +0,0 @@
package com.alttd.chat.util;
import org.bukkit.Bukkit;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class ServerName {
private static final String serverName = loadServerName();
private static String loadServerName() {
String serverName = "unknown";
try {
File serverPropertiesFile = new File(Bukkit.getWorldContainer().getParentFile(), "server.properties");
if (!serverPropertiesFile.exists()) {
ALogger.warn(String.format("server.properties file not found in %s!", serverPropertiesFile.getAbsolutePath()));
return serverName;
}
Properties properties = new Properties();
FileInputStream fis = new FileInputStream(serverPropertiesFile);
properties.load(fis);
fis.close();
serverName = properties.getProperty("server-name", serverName);
ALogger.info(String.format("Found server name [%s]", serverName));
} catch (IOException e) {
ALogger.error("Failed to read server.properties", e);
}
return serverName;
}
public static String getServerName() {
return serverName;
}
}

1
galaxy/src/main/java/com/alttd/chat/util/ToggleableForCustomChannel.java
View File

@ -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());

BIN
libs/CMI.jar Executable file
View File

Binary file not shown.

13
settings.gradle.kts
View File

@ -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.alttd.com/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)
}

10
velocity/build.gradle.kts
View File

@ -1,17 +1,17 @@
plugins {
`maven-publish`
id("io.github.goooler.shadow")
id("com.github.johnrengelman.shadow")
}
dependencies {
implementation(project(":api")) // API
compileOnly("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT")
annotationProcessor("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT")
implementation("mysql:mysql-connector-java:8.0.33") // mysql
implementation("org.spongepowered", "configurate-yaml", "4.2.0")
compileOnly("net.kyori:adventure-text-minimessage:4.23.0")
implementation("mysql:mysql-connector-java:8.0.27") // mysql
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 {

10
velocity/src/main/java/com/alttd/velocitychat/VelocityChat.java
View File

@ -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;
@ -82,9 +81,9 @@ public class VelocityChat {
ChatUserManager.addUser(console);
}
public void reloadConfig() {
chatAPI.reloadConfig();
chatAPI.reloadChatFilters();
public void ReloadConfig() {
chatAPI.ReloadConfig();
chatAPI.ReloadChatFilters();
serverHandler.cleanup();
ByteArrayDataOutput buf = ByteStreams.newDataOutput();
buf.writeUTF("reloadconfig");
@ -109,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
}

31
velocity/src/main/java/com/alttd/velocitychat/commands/PartyCommand.java
View File

@ -7,7 +7,7 @@ import com.mojang.brigadier.arguments.StringArgumentType;
import com.velocitypowered.api.command.CommandSource;
import com.velocitypowered.api.command.SimpleCommand;
import com.velocitypowered.api.proxy.Player;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import java.util.ArrayList;
@ -39,13 +39,12 @@ public class PartyCommand implements SimpleCommand {
CommandSource source = invocation.source();
if (args.length < 1) {
if (!source.hasPermission("party.use")) {
if (!source.hasPermission("party.use"))
source.sendMessage(Utility.parseMiniMessage(Config.NO_PERMISSION));
} else if (source instanceof Player) {
else if (source instanceof Player)
source.sendMessage(getHelpMessage(source));
} else {
else
source.sendMessage(Utility.parseMiniMessage(Config.NO_CONSOLE));
}
return;
}
@ -53,11 +52,10 @@ public class PartyCommand implements SimpleCommand {
.filter(subCommand -> subCommand.getName().equalsIgnoreCase(args[0]))
.findFirst()
.ifPresentOrElse(subCommand -> {
if (source.hasPermission(subCommand.getPermission())) {
if (source.hasPermission(subCommand.getPermission()))
subCommand.execute(args, source);
} else {
else
source.sendMessage(Utility.parseMiniMessage(Config.NO_PERMISSION));
}
}, () -> source.sendMessage(getHelpMessage(source)));
}
@ -66,9 +64,9 @@ public class PartyCommand implements SimpleCommand {
String[] args = invocation.arguments();
List<String> suggest = new ArrayList<>();
if (!invocation.source().hasPermission("party.use")) {
if (!invocation.source().hasPermission("party.use"))
return suggest;
} else if (args.length == 0) {
else if (args.length == 0) {
subCommands.stream()
.filter(subCommand -> invocation.source().hasPermission(subCommand.getPermission()))
.forEach(subCommand -> suggest.add(subCommand.getName()));
@ -85,12 +83,11 @@ public class PartyCommand implements SimpleCommand {
.ifPresent(subCommand -> suggest.addAll(subCommand.suggest(args, invocation.source())));
}
if (args.length == 0) {
if (args.length == 0)
return suggest;
} else {
else
return finalizeSuggest(suggest, args[args.length - 1]);
}
}
public List<String> finalizeSuggest(List<String> possibleValues, String remaining) {
List<String> finalValues = new ArrayList<>();
@ -104,18 +101,16 @@ public class PartyCommand implements SimpleCommand {
return finalValues;
}
public ComponentLike getHelpMessage(CommandSource source) {
public Component getHelpMessage(CommandSource source) {
StringBuilder stringBuilder = new StringBuilder();
subCommands.stream()
.filter(subCommand -> source.hasPermission(subCommand.getPermission()))
.forEach(subCommand -> stringBuilder.append(subCommand.getHelpMessage()).append("\n"));
if (source.hasPermission("command.chat.p")) {
if (source.hasPermission("command.chat.p"))
stringBuilder.append(Config.PARTY_HELP_CHAT).append("\n");
}
if (!stringBuilder.isEmpty()) {
if (stringBuilder.length() != 0)
stringBuilder.replace(stringBuilder.length() - 1, stringBuilder.length(), "");
}
return Utility.parseMiniMessage(Config.PARTY_HELP_WRAPPER,
Placeholder.component("commands", Utility.parseMiniMessage(stringBuilder.toString()))

2
velocity/src/main/java/com/alttd/velocitychat/commands/Reload.java
View File

@ -15,7 +15,7 @@ public class Reload {
.<CommandSource>literal("reloadchat")
.requires(ctx -> ctx.hasPermission("command.chat.reloadchat"))
.executes(context -> {
VelocityChat.getPlugin().reloadConfig();
VelocityChat.getPlugin().ReloadConfig();
return 1;
})
.build();

163
velocity/src/main/java/com/alttd/velocitychat/commands/VoteToMute.java
View File

@ -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());
}
}

287
velocity/src/main/java/com/alttd/velocitychat/commands/VoteToMuteHelper.java
View File

@ -1,287 +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 net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
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>").asComponent();
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) {
ComponentLike 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());
}
}

5
velocity/src/main/java/com/alttd/velocitychat/commands/partysubcommands/Disband.java
View File

@ -46,12 +46,11 @@ public class Disband implements SubCommand {
source.sendMessage(Utility.parseMiniMessage(getHelpMessage()));
return;
}
VelocityChat.getPlugin().getChatHandler()
.sendPartyMessage(party,
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.DISBANDED_PARTY,
Placeholder.unparsed("owner", player.getUsername()),
Placeholder.unparsed("party", party.getPartyName())
).asComponent(), null);
), null);
party.delete();
}

9
velocity/src/main/java/com/alttd/velocitychat/commands/partysubcommands/Info.java
View File

@ -40,11 +40,10 @@ public class Info implements SubCommand {
List<Component> displayNames = new ArrayList<>();
for (PartyUser partyUser : party.getPartyUsers()) {
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(partyUser.getUuid());
if (optionalPlayer.isPresent() && optionalPlayer.get().isActive()) {
displayNames.add(Config.ONLINE_PREFIX.asComponent().append(partyUser.getDisplayName()));
} else {
displayNames.add(Config.OFFLINE_PREFIX.asComponent().append(partyUser.getDisplayName()));
}
if (optionalPlayer.isPresent() && optionalPlayer.get().isActive())
displayNames.add(Config.ONLINE_PREFIX.append(partyUser.getDisplayName()));
else
displayNames.add(Config.OFFLINE_PREFIX.append(partyUser.getDisplayName()));
}
PartyUser owner = party.getPartyUser(party.getOwnerUuid());

5
velocity/src/main/java/com/alttd/velocitychat/commands/partysubcommands/Join.java
View File

@ -52,12 +52,11 @@ public class Join implements SubCommand {
}
party.addUser(chatUser, player.getUsername());
source.sendMessage(Utility.parseMiniMessage(Config.JOINED_PARTY, Placeholder.parsed("party_name", party.getPartyName())));
VelocityChat.getPlugin().getChatHandler()
.sendPartyMessage(party,
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.PLAYER_JOINED_PARTY,
Placeholder.component("player_name", chatUser.getDisplayName()),
Placeholder.parsed("party_name", party.getPartyName())
).asComponent(), null);
), null);
}
@Override

15
velocity/src/main/java/com/alttd/velocitychat/commands/partysubcommands/Leave.java
View File

@ -35,31 +35,28 @@ public class Leave implements SubCommand {
return;
}
Optional<ServerConnection> currentServer = player.getCurrentServer();
if (currentServer.isEmpty()) {
if (currentServer.isEmpty())
return;
}
party.removeUser(player.getUniqueId());
if (party.getOwnerUuid().equals(player.getUniqueId())) {
if (!party.getPartyUsers().isEmpty()) {
if (party.getPartyUsers().size() > 0) {
UUID uuid = party.setNewOwner();
source.sendMessage(Utility.parseMiniMessage(Config.NOTIFY_FINDING_NEW_OWNER));
VelocityChat.getPlugin().getChatHandler()
.sendPartyMessage(party,
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.OWNER_LEFT_PARTY,
Placeholder.unparsed("old_owner", player.getUsername()),
Placeholder.unparsed("new_owner", party.getPartyUser(uuid).getPlayerName())
).asComponent(), null);
), null);
} else {
party.delete();
}
} else {
source.sendMessage(Utility.parseMiniMessage(Config.LEFT_PARTY));
VelocityChat.getPlugin().getChatHandler()
.sendPartyMessage(party,
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.PLAYER_LEFT_PARTY,
Placeholder.unparsed("player_name", player.getUsername())
).asComponent(), null);
), null);
}
}

5
velocity/src/main/java/com/alttd/velocitychat/commands/partysubcommands/Name.java
View File

@ -52,12 +52,11 @@ public class Name implements SubCommand {
String oldName = party.getPartyName();
party.setPartyName(args[1]);
VelocityChat.getPlugin().getChatHandler()
.sendPartyMessage(party, Utility.parseMiniMessage(Config.RENAMED_PARTY,
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party, Utility.parseMiniMessage(Config.RENAMED_PARTY,
Placeholder.component("owner", ChatUserManager.getChatUser(player.getUniqueId()).getDisplayName()),
Placeholder.unparsed("old_name", oldName),
Placeholder.unparsed("new_name", args[1])
).asComponent(), null);
), null);
}
@Override

18
velocity/src/main/java/com/alttd/velocitychat/commands/partysubcommands/Owner.java
View File

@ -14,6 +14,7 @@ import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;
public class Owner implements SubCommand {
@Override
@ -48,31 +49,26 @@ public class Owner implements SubCommand {
return;
}
party.setNewOwner(partyUser.getUuid());
VelocityChat.getPlugin().getChatHandler()
.sendPartyMessage(party,
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.NEW_PARTY_OWNER,
Placeholder.unparsed("old_owner", player.getUsername()),
Placeholder.unparsed("new_owner", partyUser.getPlayerName())
).asComponent(), null);
), null);
}
@Override
public List<String> suggest(String[] args, CommandSource source) {
ArrayList<String> suggest = new ArrayList<>();
if (!(source instanceof Player player)) {
if (!(source instanceof Player player))
return suggest;
}
UUID uuid = player.getUniqueId();
Party party = PartyManager.getParty(uuid);
if (party == null) {
if (party == null)
return suggest;
}
if (args.length == 1 || args.length == 2) {
if (args.length == 1 || args.length == 2)
suggest.addAll(party.getPartyUsers().stream()
.filter(partyUser -> !partyUser.getUuid().equals(uuid))
.map(PartyUser::getPlayerName)
.toList());
}
.map(PartyUser::getPlayerName).collect(Collectors.toList()));
return suggest;
}

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

@ -1,244 +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.ComponentLike;
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>").asComponent();
private final Player votedPlayer;
private final Player startedByPlayer;
private final HashSet<UUID> votedFor = new HashSet<>();
private final 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;
}
ComponentLike 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() {
ComponentLike 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() {
ComponentLike 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 ComponentLike 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;
}
}

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

@ -1,132 +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>").asComponent();
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
)).asComponent()
)
.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;
}
}

10
velocity/src/main/java/com/alttd/velocitychat/data/ServerWrapper.java
View File

@ -3,7 +3,7 @@ package com.alttd.velocitychat.data;
import com.alttd.chat.config.ServerConfig;
import com.alttd.chat.managers.ChatUserManager;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import java.util.UUID;
@ -31,7 +31,8 @@ public class ServerWrapper {
return serverName;
}
public boolean globalChat() {
public boolean globalChat()
{
return globalChat;
}
@ -39,11 +40,10 @@ public class ServerWrapper {
return joinMessages;
}
public void sendJoinLeaveMessage(UUID uuid, ComponentLike component) {
if (joinMessages()) {
public void sendJoinLeaveMessage(UUID uuid, Component component) {
if(joinMessages())
getRegisteredServer().getPlayersConnected().stream()
.filter(p -> !ChatUserManager.getChatUser(p.getUniqueId()).getIgnoredPlayers().contains(uuid))
.forEach(p -> p.sendMessage(component));
}
}
}

91
velocity/src/main/java/com/alttd/velocitychat/handlers/ChatHandler.java
View File

@ -15,7 +15,6 @@ import com.velocitypowered.api.command.CommandSource;
import com.velocitypowered.api.proxy.Player;
import com.velocitypowered.api.proxy.ServerConnection;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
@ -25,10 +24,7 @@ import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.jetbrains.annotations.Nullable;
import java.time.Duration;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.*;
public class ChatHandler {
@ -36,15 +32,11 @@ public class ChatHandler {
UUID uuid = UUID.fromString(sender);
ChatUser senderUser = ChatUserManager.getChatUser(uuid);
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid);
if (optionalPlayer.isEmpty()) {
return;
}
if(optionalPlayer.isEmpty()) return;
Player player = optionalPlayer.get();
Optional<Player> optionalPlayer2 = VelocityChat.getPlugin().getProxy().getPlayer(target);
if (optionalPlayer2.isEmpty()) {
return;
}
if(optionalPlayer2.isEmpty()) return;
Player player2 = optionalPlayer2.get();
ChatUser targetUser = ChatUserManager.getChatUser(player2.getUniqueId());
@ -62,7 +54,7 @@ public class ChatHandler {
serverConnection = player.getCurrentServer().get();
Component component = Utility.parseMiniMessage(Config.MESSAGESENDER
.replaceAll("<sendername>", player.getUsername())
.replaceAll("<receivername>", player2.getUsername()), Placeholders).asComponent();
.replaceAll("<receivername>", player2.getUsername()), Placeholders);
ByteArrayDataOutput buf = ByteStreams.newDataOutput();
buf.writeUTF("privatemessageout");
buf.writeUTF(player.getUniqueId().toString());
@ -75,7 +67,7 @@ public class ChatHandler {
serverConnection = player2.getCurrentServer().get();
component = Utility.parseMiniMessage(Config.MESSAGERECIEVER
.replaceAll("<sendername>", player.getUsername())
.replaceAll("<receivername>", player2.getUsername()), Placeholders).asComponent();
.replaceAll("<receivername>", player2.getUsername()), Placeholders);
buf = ByteStreams.newDataOutput();
buf.writeUTF("privatemessagein");
buf.writeUTF(player2.getUniqueId().toString());
@ -94,7 +86,7 @@ public class ChatHandler {
Placeholder.unparsed("target", (target.isEmpty() ? " tried to say: " : " -> " + target + ": ")),
Placeholder.unparsed("input", input)
);
ComponentLike blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, Placeholders);
Component blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, Placeholders);
serverConnection.getServer().getPlayersConnected().forEach(pl ->{
if (pl.hasPermission("chat.alert-blocked")) {
@ -105,13 +97,13 @@ public class ChatHandler {
"this constitutes as your only warning. Any further attempts at bypassing the filter will result in staff intervention.</red>"));
}
public void sendPartyMessage(Party party, Component message, @Nullable List<UUID> ignoredPlayers) {
public void sendPartyMessage(Party party, Component message, @Nullable List<UUID> ignoredPlayers)
{
VelocityChat.getPlugin().getProxy().getAllPlayers().stream()
.filter(pl -> {
UUID uuid = pl.getUniqueId();
if (ignoredPlayers != null && ignoredPlayers.contains(uuid)) {
if (ignoredPlayers != null && ignoredPlayers.contains(uuid))
return false;
}
return party.getPartyUsers().stream().anyMatch(pu -> pu.getUuid().equals(uuid));
}).forEach(pl -> {
pl.sendMessage(message);
@ -122,9 +114,7 @@ public class ChatHandler {
public void sendPartyMessage(UUID uuid, String message, Component item, ServerConnection serverConnection) {
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid);
if (optionalPlayer.isEmpty()) {
return;
}
if (optionalPlayer.isEmpty()) return;
Player player = optionalPlayer.get();
ChatUser user = ChatUserManager.getChatUser(uuid);
Party party = PartyManager.getParty(user.getPartyId());
@ -132,7 +122,7 @@ public class ChatHandler {
player.sendMessage(Utility.parseMiniMessage(Config.NOT_IN_A_PARTY));
return;
}
ComponentLike senderName = user.getDisplayName();
Component senderName = user.getDisplayName();
TagResolver Placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName),
@ -142,7 +132,7 @@ public class ChatHandler {
Placeholder.unparsed("server", serverConnection.getServer().getServerInfo().getName())
);
Component partyMessage = Utility.parseMiniMessage(Config.PARTY_FORMAT, Placeholders).asComponent()
Component partyMessage = Utility.parseMiniMessage(Config.PARTY_FORMAT, Placeholders)
.replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(item).build());
ModifiableString modifiableString = new ModifiableString(partyMessage);
@ -155,7 +145,7 @@ public class ChatHandler {
sendPartyMessage(party, partyMessage, user.getIgnoredBy());
ComponentLike spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, Placeholders);
Component spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, Placeholders);
for(Player pl : serverConnection.getServer().getPlayersConnected()) {
if(pl.hasPermission(Config.SPYPERMISSION) && !party.getPartyUsersUuid().contains(pl.getUniqueId())) {
pl.sendMessage(spyMessage);
@ -167,20 +157,18 @@ public class ChatHandler {
public void globalAdminChat(String message) {
Component component = GsonComponentSerializer.gson().deserialize(message);
VelocityChat.getPlugin().getProxy().getAllPlayers()
.stream()
.filter(target -> target.hasPermission("command.chat.globaladminchat"))
.forEach(target -> target.sendMessage(component));
VelocityChat.getPlugin().getProxy().getAllPlayers().stream().filter(target -> target.hasPermission("command.chat.globaladminchat")/*TODO permission*/).forEach(target -> {
target.sendMessage(component);
});
}
public void globalAdminChat(CommandSource commandSource, String message) {
ComponentLike senderName = Component.text(Config.CONSOLENAME);
Component senderName = Component.text(Config.CONSOLENAME);
String serverName = "Altitude";
if (commandSource instanceof Player sender) {
if (commandSource instanceof Player) {
Player sender = (Player) commandSource;
ChatUser user = ChatUserManager.getChatUser(sender.getUniqueId());
if (user == null) {
return;
}
if(user == null) return;
senderName = user.getDisplayName();
serverName = sender.getCurrentServer().isPresent() ? sender.getCurrentServer().get().getServerInfo().getName() : "Altitude";
}
@ -190,16 +178,15 @@ public class ChatHandler {
Placeholder.component("sender", senderName),
Placeholder.unparsed("server", serverName));
ComponentLike component = Utility.parseMiniMessage(Config.GACFORMAT, Placeholders);
Component component = Utility.parseMiniMessage(Config.GACFORMAT, Placeholders);
VelocityChat.getPlugin().getProxy().getAllPlayers()
.stream()
.filter(target -> target.hasPermission("command.chat.globaladminchat"))
.forEach(target -> target.sendMessage(component));
VelocityChat.getPlugin().getProxy().getAllPlayers().stream().filter(target -> target.hasPermission("command.chat.globaladminchat")/*TODO permission*/).forEach(target -> {
target.sendMessage(component);
});
}
public void sendMail(CommandSource commandSource, String recipient, String message) {
UUID uuid = Config.CONSOLEUUID;
UUID uuid = Config.CONSOLEUUID;;
String senderName = Config.CONSOLENAME;
UUID targetUUID;
if (commandSource instanceof Player player) {
@ -218,10 +205,6 @@ public class ChatHandler {
}
Mail mail = new Mail(targetUUID, uuid, message);
ChatUser chatUser = ChatUserManager.getChatUser(targetUUID);
if (chatUser.getIgnoredPlayers().contains(uuid)) {
commandSource.sendMessage(Utility.parseMiniMessage("<red>You cannot mail this player</red>"));
return;
}
chatUser.addMail(mail);
// TODO load from config
String finalSenderName = senderName;
@ -261,7 +244,7 @@ public class ChatHandler {
}
private Component parseMails(List<Mail> mails, boolean mark) {
Component component = Utility.parseMiniMessage(Config.mailHeader).asComponent();
Component component = Utility.parseMiniMessage(Config.mailHeader);
for (Mail mail : mails) {
if (mail.isUnRead() && mark) {
mail.setReadTime(System.currentTimeMillis());
@ -276,13 +259,27 @@ public class ChatHandler {
Placeholder.unparsed("date", date.toString()),
Placeholder.unparsed("time_ago", getTimeAgo(Duration.between(date.toInstant(), new Date().toInstant())))
);
ComponentLike mailMessage = Utility.parseMiniMessage(Config.mailBody, Placeholders);
Component mailMessage = Utility.parseMiniMessage(Config.mailBody, Placeholders);
component = component.append(Component.newline()).append(mailMessage);
}
component = component.append(Component.newline()).append(Utility.parseMiniMessage(Config.mailFooter));
return component;
}
public void partyChat(String partyId, UUID uuid, Component message) {
Party party = PartyManager.getParty(Integer.parseInt(partyId));
if (party == null) {
ALogger.warn("Received a non existent party");
return;
}
List<UUID> ignoredPlayers = ChatUserManager.getChatUser(uuid).getIgnoredPlayers();
List<UUID> partyUsersUuid = party.getPartyUsersUuid();
VelocityChat.getPlugin().getProxy().getAllPlayers().stream()
.filter(p -> partyUsersUuid.contains(p.getUniqueId()))
.filter(p -> !ignoredPlayers.contains(p.getUniqueId()))
.forEach(p -> p.sendMessage(message));
}
public void mutePlayer(String uuid, boolean muted) {
ByteArrayDataOutput buf = ByteStreams.newDataOutput();
buf.writeUTF("chatpunishments");
@ -292,12 +289,10 @@ public class ChatHandler {
private String getTimeAgo(Duration duration) {
StringBuilder stringBuilder = new StringBuilder();
if (duration.toDays() != 0) {
if (duration.toDays() != 0)
stringBuilder.append(duration.toDays()).append("d ");
}
if (duration.toHoursPart() != 0 || !stringBuilder.isEmpty()) {
if (duration.toHoursPart() != 0 || !stringBuilder.isEmpty())
stringBuilder.append(duration.toHoursPart()).append("h ");
}
stringBuilder.append(duration.toMinutesPart()).append("m ago");
return stringBuilder.toString();
}

19
velocity/src/main/java/com/alttd/velocitychat/listeners/ChatListener.java
View File

@ -8,12 +8,15 @@ import com.velocitypowered.api.command.CommandSource;
import com.velocitypowered.api.event.PostOrder;
import com.velocitypowered.api.event.Subscribe;
import com.velocitypowered.api.proxy.Player;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import java.util.ArrayList;
import java.util.List;
// TODO code CLEANUP
public class ChatListener {
private final VelocityChat plugin;
private VelocityChat plugin;
public ChatListener() {
plugin = VelocityChat.getPlugin();
@ -27,20 +30,18 @@ public class ChatListener {
if (commandSource instanceof Player) {
Player sender = (Player) event.getSender();
senderName = sender.getUsername();
serverName = sender.getCurrentServer().isPresent()
? sender.getCurrentServer().get().getServerInfo().getName() : "Altitude";
serverName = sender.getCurrentServer().isPresent() ? sender.getCurrentServer().get().getServerInfo().getName() : "Altitude";
}
ComponentLike message = Utility.parseMiniMessage(Config.GACFORMAT,
Component message = Utility.parseMiniMessage(Config.GACFORMAT,
Placeholder.parsed("sender", senderName),
Placeholder.component("message", Utility.parseMiniMessage(event.getMessage())),
Placeholder.parsed("server", serverName)
);
plugin.getProxy().getAllPlayers()
.stream()
.filter(target -> target.hasPermission("command.chat.globaladminchat"))
.forEach(target -> target.sendMessage(message));
plugin.getProxy().getAllPlayers().stream().filter(target -> target.hasPermission("command.chat.globaladminchat")).forEach(target -> {
target.sendMessage(message);
});
}
}

19
velocity/src/main/java/com/alttd/velocitychat/listeners/PluginMessageListener.java
View File

@ -4,14 +4,11 @@ import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.util.ALogger;
import com.alttd.proxydiscordlink.DiscordLink;
import com.alttd.proxydiscordlink.lib.net.dv8tion.jda.api.EmbedBuilder;
import com.alttd.velocitychat.VelocityChat;
import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteStreams;
import com.velocitypowered.api.event.Subscribe;
import com.velocitypowered.api.event.connection.PluginMessageEvent;
import com.velocitypowered.api.proxy.ConsoleCommandSource;
import com.velocitypowered.api.proxy.Player;
import com.velocitypowered.api.proxy.ProxyServer;
import com.velocitypowered.api.proxy.ServerConnection;
@ -19,10 +16,8 @@ import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
import java.awt.*;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.util.Optional;
import java.util.UUID;
public class PluginMessageListener {
@ -98,20 +93,6 @@ public class PluginMessageListener {
proxy.getAllServers().forEach(registeredServer ->
registeredServer.sendPluginMessage(VelocityChat.getPlugin().getChannelIdentifier(), event.getData()));
}
case "punish" -> {
String playerName = in.readUTF();
ProxyServer proxy = VelocityChat.getPlugin().getProxy();
ConsoleCommandSource consoleCommandSource = proxy.getConsoleCommandSource();
proxy.getCommandManager().executeAsync(consoleCommandSource, String.format("ban %s Automatic ban, please appeal if you feel review is needed.", playerName));
ALogger.info(String.format("Auto banned %s due to violating the `punish` filter.", playerName));
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setTitle("Automatic ban through the chat filter");
embedBuilder.setAuthor(playerName, null, "https://crafatar.com/avatars/" + in.readUTF() + "?overlay");
embedBuilder.setDescription(String.format("`%s`\n\n Auto permanent ban\n\n Auto banned for violating the `punish` chat filter. This could be a false positive! Their message was\n||%s||", playerName, in.readUTF()));
embedBuilder.setColor(Color.RED);
DiscordLink.getPlugin().getBot().sendEmbedToDiscord(514922317923614728L, embedBuilder, -1);
}
default -> {
VelocityChat.getPlugin().getLogger().info("server " + event.getSource());
ProxyServer proxy = VelocityChat.getPlugin().getProxy();

78
velocity/src/main/java/com/alttd/velocitychat/listeners/ProxyPlayerListener.java
View File

@ -1,16 +1,15 @@
package com.alttd.velocitychat.listeners;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Mail;
import com.alttd.chat.objects.Party;
import com.alttd.chat.util.Utility;
import com.alttd.velocitychat.VelocityChat;
import com.alttd.velocitychat.commands.vote_to_mute.ActiveVoteToMute;
import com.alttd.chat.config.Config;
import com.alttd.velocitychat.data.ServerWrapper;
import com.alttd.velocitychat.handlers.ServerHandler;
import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.objects.Party;
import com.velocitypowered.api.event.PostOrder;
import com.velocitypowered.api.event.Subscribe;
import com.velocitypowered.api.event.connection.DisconnectEvent;
@ -18,19 +17,12 @@ 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.ComponentLike;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.title.Title;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.*;
public class ProxyPlayerListener {
@ -39,17 +31,14 @@ public class ProxyPlayerListener {
Player player = event.getPlayer();
UUID uuid = player.getUniqueId();
Party party = PartyManager.getParty(event.getPlayer().getUniqueId());
if (party == null) {
return;
}
if (party == null) return;
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
if (chatUser == null) {
if (chatUser == null)
return;
}
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.PARTY_MEMBER_LOGGED_ON,
Placeholder.component("player", chatUser.getDisplayName())
).asComponent(),
),
chatUser.getIgnoredPlayers());
// TODO setup ChatUser on Proxy
//VelocityChat.getPlugin().getChatHandler().addPlayer(new ChatPlayer(event.getPlayer().getUniqueId()));
@ -59,65 +48,40 @@ 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()) {
if (unReadMail.isEmpty())
return;
}
VelocityChat plugin = VelocityChat.getPlugin();
plugin.getProxy().getScheduler().buildTask(plugin, () -> {
if (!player.isActive()) {
return;
}
ComponentLike message = Utility.parseMiniMessage(Config.mailUnread,
Placeholder.unparsed("amount", String.valueOf(unReadMail.size())));
player.sendMessage(message);
player.showTitle(Title.title(message.asComponent(), Component.empty()));
}).delay(Config.mailDisplayDelay * 50L, TimeUnit.MILLISECONDS).schedule();
player.sendMessage(Utility.parseMiniMessage(Config.mailUnread,
Placeholder.unparsed("amount", String.valueOf(unReadMail.size()))
));
}
@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;
}
if (party == null) return;
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
if (chatUser == null) {
if (chatUser == null)
return;
}
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.PARTY_MEMBER_LOGGED_OFF,
Placeholder.component("player", chatUser.getDisplayName())
).asComponent(),
),
chatUser.getIgnoredPlayers());
// TODO setup ChatUser on Proxy
//VelocityChat.getPlugin().getChatHandler().removePlayer(event.getPlayer().getUniqueId());
}
private static final HashSet<UUID> silentJoin = new HashSet<>();
public static void addSilentJoin(UUID uuid) {
public static void addSilentJoin(UUID uuid)
{
silentJoin.add(uuid);
}
@ -137,7 +101,7 @@ public class ProxyPlayerListener {
);
if (silentJoin.remove(uuid)) {
ComponentLike message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED_FROM,
Component message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED_FROM,
placeholders);
event.getServer().getPlayersConnected().stream()
.filter(player1 -> player1.hasPermission("command.chat.silent-join-notify"))
@ -155,7 +119,7 @@ public class ProxyPlayerListener {
}
} else {
if (silentJoin.remove(uuid)) {
ComponentLike message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED,
Component message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED,
Placeholder.unparsed("player", player.getUsername()));
event.getServer().getPlayersConnected().stream()
.filter(player1 -> player1.hasPermission("command.chat.silent-join-notify"))