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

Compare commits

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

2 Commits
bbd421c423 ... fc7860145f

Author SHA1 Message Date
Teriuihi fc7860145f Updated to 1.21 by switching to cosmos 2025-06-21 00:53:55 +02:00
Teriuihi 1dd19f0543 Update dependencies and build configuration 2025-06-20 23:26:54 +02:00
45 changed files with 980 additions and 1028 deletions
Show Stats Expand all files Collapse all files

6
api/build.gradle.kts
View File

@ -7,8 +7,8 @@ dependencies {
// exclude("net.kyori") // exclude("net.kyori")
// } // }
compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT") compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
compileOnly("org.spongepowered:configurate-yaml:4.1.2") // Configurate compileOnly("org.spongepowered:configurate-yaml:4.2.0") // Configurate
compileOnly("net.luckperms:api:5.3") // Luckperms compileOnly("net.luckperms:api:5.5") // Luckperms
} }
publishing { publishing {
@ -18,7 +18,7 @@ publishing {
} }
} }
repositories{ repositories {
maven { maven {
name = "maven" name = "maven"
url = uri("https://repo.destro.xyz/snapshots") url = uri("https://repo.destro.xyz/snapshots")

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

@ -1,10 +1,11 @@
package com.alttd.chat.config; package com.alttd.chat.config;
import com.alttd.chat.objects.channels.CustomChannel; import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import com.google.common.collect.Lists; import com.google.common.collect.Lists;
import io.leangen.geantyref.TypeToken; import io.leangen.geantyref.TypeToken;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.ComponentLike;
import org.spongepowered.configurate.ConfigurationNode; import org.spongepowered.configurate.ConfigurationNode;
import org.spongepowered.configurate.ConfigurationOptions; import org.spongepowered.configurate.ConfigurationOptions;
import org.spongepowered.configurate.serialize.SerializationException; import org.spongepowered.configurate.serialize.SerializationException;
@ -19,6 +20,7 @@ import java.lang.reflect.Modifier;
import java.util.*; import java.util.*;
import java.util.regex.Pattern; import java.util.regex.Pattern;
@SuppressWarnings("unused")
public final class Config { public final class Config {
private static final Pattern PATH_PATTERN = Pattern.compile("\\."); private static final Pattern PATH_PATTERN = Pattern.compile("\\.");
private static final String HEADER = ""; private static final String HEADER = "";
@ -31,6 +33,7 @@ public final class Config {
static boolean verbose; static boolean verbose;
public static File CONFIGPATH; public static File CONFIGPATH;
public static void init() { public static void init() {
CONFIGPATH = new File(File.separator + "mnt" + File.separator + "configs" + File.separator + "ChatPlugin"); CONFIGPATH = new File(File.separator + "mnt" + File.separator + "configs" + File.separator + "ChatPlugin");
CONFIG_FILE = new File(CONFIGPATH, "config.yml"); CONFIG_FILE = new File(CONFIGPATH, "config.yml");
@ -39,24 +42,24 @@ public final class Config {
.nodeStyle(NodeStyle.BLOCK) .nodeStyle(NodeStyle.BLOCK)
.build(); .build();
if (!CONFIG_FILE.getParentFile().exists()) { if (!CONFIG_FILE.getParentFile().exists()) {
if(!CONFIG_FILE.getParentFile().mkdirs()) { if (!CONFIG_FILE.getParentFile().mkdirs()) {
return; return;
} }
} }
if (!CONFIG_FILE.exists()) { if (!CONFIG_FILE.exists()) {
try { try {
if(!CONFIG_FILE.createNewFile()) { if (!CONFIG_FILE.createNewFile()) {
return; return;
} }
} catch (IOException error) { } catch (IOException error) {
error.printStackTrace(); ALogger.error(error.getMessage(), error);
} }
} }
try { try {
config = configLoader.load(ConfigurationOptions.defaults().header(HEADER).shouldCopyDefaults(false)); config = configLoader.load(ConfigurationOptions.defaults().header(HEADER).shouldCopyDefaults(false));
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); ALogger.error(e.getMessage(), e);
} }
verbose = getBoolean("verbose", true); verbose = getBoolean("verbose", true);
@ -66,7 +69,7 @@ public final class Config {
try { try {
configLoader.save(config); configLoader.save(config);
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); ALogger.error(e.getMessage(), e);
} }
} }
@ -78,7 +81,7 @@ public final class Config {
method.setAccessible(true); method.setAccessible(true);
method.invoke(instance); method.invoke(instance);
} catch (InvocationTargetException | IllegalAccessException ex) { } catch (InvocationTargetException | IllegalAccessException ex) {
ex.printStackTrace(); ALogger.error(ex.getMessage(), ex);
} }
} }
} }
@ -86,7 +89,7 @@ public final class Config {
try { try {
configLoader.save(config); configLoader.save(config);
} catch (IOException ex) { } catch (IOException ex) {
ex.printStackTrace(); ALogger.error(ex.getMessage(), ex);
} }
} }
@ -94,7 +97,7 @@ public final class Config {
try { try {
configLoader.save(config); configLoader.save(config);
} catch (IOException ex) { } catch (IOException ex) {
ex.printStackTrace(); ALogger.error(ex.getMessage(), ex);
} }
} }
@ -103,21 +106,22 @@ public final class Config {
} }
private static void set(String path, Object def) { private static void set(String path, Object def) {
if(config.node(splitPath(path)).virtual()) { if (config.node(splitPath(path)).virtual()) {
try { try {
config.node(splitPath(path)).set(def); config.node(splitPath(path)).set(def);
} catch (SerializationException e) { } catch (SerializationException e) {
e.printStackTrace(); ALogger.error(e.getMessage(), e);
} }
} }
} }
private static void setString(String path, String def) { private static void setString(String path, String def) {
try { 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); config.node(splitPath(path)).set(io.leangen.geantyref.TypeToken.get(String.class), def);
} catch(SerializationException ex) { }
ex.printStackTrace(); } catch (SerializationException ex) {
ALogger.error(ex.getMessage(), ex);
} }
} }
@ -150,21 +154,23 @@ public final class Config {
try { try {
set(path, def); set(path, def);
return config.node(splitPath(path)).getList(TypeToken.get(String.class)); return config.node(splitPath(path)).getList(TypeToken.get(String.class));
} catch(SerializationException ex) { } catch (SerializationException ex) {
ex.printStackTrace(); ALogger.error(ex.getMessage(), ex);
} }
return new ArrayList<>(); return new ArrayList<>();
} }
private static ConfigurationNode getNode(String path) { private static ConfigurationNode getNode(String path) {
if(config.node(splitPath(path)).virtual()) { if (config.node(splitPath(path)).virtual()) {
//new RegexConfig("Dummy"); //new RegexConfig("Dummy");
} }
config.childrenMap(); config.childrenMap();
return config.node(splitPath(path)); 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> PREFIXGROUPS = new ArrayList<>();
public static List<String> CONFLICTINGPREFIXGROUPS = new ArrayList<>(); public static List<String> CONFLICTINGPREFIXGROUPS = new ArrayList<>();
public static List<String> STAFFGROUPS = new ArrayList<>(); public static List<String> STAFFGROUPS = new ArrayList<>();
@ -173,13 +179,14 @@ public final class Config {
public static UUID CONSOLEUUID = UUID.randomUUID(); public static UUID CONSOLEUUID = UUID.randomUUID();
public static int EMOTELIMIT = 3; public static int EMOTELIMIT = 3;
public static String MENTIONPLAYERTAG = "<aqua>@</aqua>"; public static String MENTIONPLAYERTAG = "<aqua>@</aqua>";
private static void settings() { private static void settings() {
PREFIXGROUPS = getList("settings.prefix-groups", 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", CONFLICTINGPREFIXGROUPS = getList("settings.prefix-conflicts-groups",
Lists.newArrayList("eventteam", "eventleader")); Lists.newArrayList("eventteam", "eventleader"));
STAFFGROUPS = getList("settings.staff-groups", STAFFGROUPS = getList("settings.staff-groups",
Lists.newArrayList("trainee", "moderator", "headmod", "admin", "manager", "owner")); Lists.newArrayList("trainee", "moderator", "headmod", "admin", "manager", "owner"));
CONSOLENAME = getString("settings.console-name", CONSOLENAME); CONSOLENAME = getString("settings.console-name", CONSOLENAME);
CONSOLEUUID = UUID.fromString(getString("settings.console-uuid", CONSOLEUUID.toString())); CONSOLEUUID = UUID.fromString(getString("settings.console-uuid", CONSOLEUUID.toString()));
MINIMIUMSTAFFRANK = getString("settings.minimum-staff-rank", MINIMIUMSTAFFRANK); MINIMIUMSTAFFRANK = getString("settings.minimum-staff-rank", MINIMIUMSTAFFRANK);
@ -193,6 +200,7 @@ public final class Config {
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 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 MESSAGESPY = "<gray>(<gray><sendername></gray> -> <receivername>) <message>";
public static String RECEIVER_DOES_NOT_EXIST = "<red><player> is not a valid player.</red>"; public static String RECEIVER_DOES_NOT_EXIST = "<red><player> is not a valid player.</red>";
private static void messageCommand() { private static void messageCommand() {
MESSAGECOMMANDALIASES.clear(); MESSAGECOMMANDALIASES.clear();
REPLYCOMMANDALIASES.clear(); REPLYCOMMANDALIASES.clear();
@ -210,6 +218,7 @@ public final class Config {
public static String GCNOTENABLED = "You don't have global chat enabled."; 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 String GCONCOOLDOWN = "You have to wait <cooldown> seconds before using this feature again.";
public static int GCCOOLDOWN = 30; public static int GCCOOLDOWN = 30;
private static void globalChat() { private static void globalChat() {
GCFORMAT = getString("commands.globalchat.format", GCFORMAT); GCFORMAT = getString("commands.globalchat.format", GCFORMAT);
GCPERMISSION = getString("commands.globalchat.view-chat-permission", GCPERMISSION); GCPERMISSION = getString("commands.globalchat.view-chat-permission", GCPERMISSION);
@ -221,6 +230,7 @@ public final class Config {
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>"; public static String URLFORMAT = "<click:OPEN_URL:<clickurl>><url></click>";
private static void Chat() { private static void Chat() {
CHATFORMAT = getString("chat.format", CHATFORMAT); CHATFORMAT = getString("chat.format", CHATFORMAT);
URLFORMAT = getString("chat.urlformat", URLFORMAT); URLFORMAT = getString("chat.urlformat", URLFORMAT);
@ -228,17 +238,20 @@ public final class Config {
public static List<String> GACECOMMANDALIASES = new ArrayList<>(); 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() { private static void globalAdminChat() {
GACECOMMANDALIASES = getList("commands.globaladminchat.aliases", Lists.newArrayList("acg")); GACECOMMANDALIASES = getList("commands.globaladminchat.aliases", Lists.newArrayList("acg"));
GACFORMAT = getString("commands.globaladminchat.format", GACFORMAT); GACFORMAT = getString("commands.globaladminchat.format", GACFORMAT);
} }
public static String MESSAGECHANNEL = "altitude:chatplugin"; public static String MESSAGECHANNEL = "altitude:chatplugin";
private static void messageChannels() { private static void messageChannels() {
MESSAGECHANNEL = getString("settings.message-channel", MESSAGECHANNEL); MESSAGECHANNEL = getString("settings.message-channel", MESSAGECHANNEL);
} }
public static ConfigurationNode REGEXNODE = null; public static ConfigurationNode REGEXNODE = null;
private static void RegexNOde() { private static void RegexNOde() {
REGEXNODE = getNode("regex-settings"); REGEXNODE = getNode("regex-settings");
} }
@ -247,6 +260,7 @@ public final class Config {
public static String SERVERSWTICHMESSAGETO = "<gray>* <player> leaves to <to_server>..."; public static String SERVERSWTICHMESSAGETO = "<gray>* <player> leaves to <to_server>...";
public static String SERVERJOINMESSAGE = "<green>* <player> appears from thin air..."; public static String SERVERJOINMESSAGE = "<green>* <player> appears from thin air...";
public static String SERVERLEAVEMESSAGE = "<red>* <player> vanishes in the mist..."; public static String SERVERLEAVEMESSAGE = "<red>* <player> vanishes in the mist...";
private static void JoinLeaveMessages() { private static void JoinLeaveMessages() {
SERVERSWTICHMESSAGEFROM = getString("messages.switch-server-from", SERVERSWTICHMESSAGEFROM); SERVERSWTICHMESSAGEFROM = getString("messages.switch-server-from", SERVERSWTICHMESSAGEFROM);
SERVERSWTICHMESSAGETO = getString("messages.switch-server-to", SERVERSWTICHMESSAGETO); SERVERSWTICHMESSAGETO = getString("messages.switch-server-to", SERVERSWTICHMESSAGETO);
@ -260,7 +274,7 @@ public final class Config {
public static String NO_PERMISSION = "<red>You don't have permission to use this command.</red>"; 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 NO_CONSOLE = "<red>This command can not be used by console</red>";
public static String CREATED_PARTY = "<green>You created a chat party called: " + public static String CREATED_PARTY = "<green>You created a chat party called: " +
"'<gold><party_name></gold>' with the password: '<gold><party_password></gold>'</green>"; "'<gold><party_name></gold>' with the password: '<gold><party_password></gold>'</green>";
public static String NOT_IN_A_PARTY = "<red>You're not in a chat party.</red>"; public static String NOT_IN_A_PARTY = "<red>You're not in a chat party.</red>";
public static String NOT_YOUR_PARTY = "<red>You don't own this chat party.</red>"; public static String NOT_YOUR_PARTY = "<red>You don't own this chat party.</red>";
public static String NOT_A_PARTY = "<red>This chat party does not exist.</red>"; public static String NOT_A_PARTY = "<red>This chat party does not exist.</red>";
@ -283,23 +297,24 @@ public final class Config {
public static String ALREADY_IN_THIS_PARTY = "<red>You're already in <party>!</red>"; public static String ALREADY_IN_THIS_PARTY = "<red>You're already in <party>!</red>";
public static String SENT_PARTY_INV = "<green>You send a chat party invite to <player>!</green>"; public static String SENT_PARTY_INV = "<green>You send a chat party invite to <player>!</green>";
public static String JOIN_PARTY_CLICK_MESSAGE = "<click:run_command:'/party join <party> <party_password>'>" + public static String JOIN_PARTY_CLICK_MESSAGE = "<click:run_command:'/party join <party> <party_password>'>" +
"<dark_aqua>You received an invite to join <party>, click this message to accept.</dark_aqua></click>"; "<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_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 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 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> " + 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."; "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 = """ public static String PARTY_INFO = """
<gold><bold>Chat party info</bold>: <gold><bold>Chat party info</bold>:
</gold><green>Name: <dark_aqua><party></dark_aqua> </gold><green>Name: <dark_aqua><party></dark_aqua>
Password: <dark_aqua><password></dark_aqua> Password: <dark_aqua><password></dark_aqua>
Owner: <owner> Owner: <owner>
Members: <members>"""; Members: <members>""";
public static Component ONLINE_PREFIX = null; public static ComponentLike ONLINE_PREFIX = null;
public static Component OFFLINE_PREFIX = null; public static ComponentLike OFFLINE_PREFIX = null;
public static String PARTY_TOGGLED = "<dark_aqua>Party chat toggled <status>.</dark_aqua>"; public static String PARTY_TOGGLED = "<dark_aqua>Party chat toggled <status>.</dark_aqua>";
private static void party() { private static void party() {
PARTY_FORMAT = getString("party.format", PARTY_FORMAT); PARTY_FORMAT = getString("party.format", PARTY_FORMAT);
PARTY_SPY = getString("party.spy", PARTY_SPY); PARTY_SPY = getString("party.spy", PARTY_SPY);
@ -349,6 +364,7 @@ public final class Config {
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_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_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>"; public static String PARTY_HELP_CHAT = "<green>Talk in party chat: <gold>/p <message></gold></green>";
private static void partyHelp() { private static void partyHelp() {
PARTY_HELP_WRAPPER = getString("party.help.wrapper", PARTY_HELP_WRAPPER); PARTY_HELP_WRAPPER = getString("party.help.wrapper", PARTY_HELP_WRAPPER);
PARTY_HELP_HELP = getString("party.help.help", PARTY_HELP_HELP); PARTY_HELP_HELP = getString("party.help.help", PARTY_HELP_HELP);
@ -366,10 +382,11 @@ public final class Config {
} }
public static String CUSTOM_CHANNEL_TOGGLED = "<yellow>Toggled <channel> <status>.</yellow>"; public static String CUSTOM_CHANNEL_TOGGLED = "<yellow>Toggled <channel> <status>.</yellow>";
public static Component TOGGLED_ON = null; public static ComponentLike TOGGLED_ON = null;
public static Component TOGGLED_OFF = null; public static ComponentLike TOGGLED_OFF = null;
public static double LOCAL_DISTANCE; 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 String CHANNEL_SPY = "<i><gray>SPY:</gray> <dark_gray>(<dark_gray><sender> → <channel>) <message></dark_gray>";
private static void chatChannels() { private static void chatChannels() {
ConfigurationNode node = getNode("chat-channels"); ConfigurationNode node = getNode("chat-channels");
if (node.empty()) { if (node.empty()) {
@ -383,10 +400,10 @@ public final class Config {
String channelName = Objects.requireNonNull(configurationNode.key()).toString(); String channelName = Objects.requireNonNull(configurationNode.key()).toString();
String key = "chat-channels." + channelName + "."; String key = "chat-channels." + channelName + ".";
new CustomChannel(channelName, new CustomChannel(channelName,
getString(key + "format", ""), getString(key + "format", ""),
getList(key + "servers", Collections.EMPTY_LIST), getList(key + "servers", Collections.EMPTY_LIST),
getBoolean(key + "proxy", false), getBoolean(key + "proxy", false),
getBoolean(key + "local", false) getBoolean(key + "local", false)
); );
} }
@ -399,6 +416,7 @@ public final class Config {
public static String SERVERMUTEPERMISSION = "chat.command.mute-server"; public static String SERVERMUTEPERMISSION = "chat.command.mute-server";
public static String SPYPERMISSION = "chat.socialspy"; public static String SPYPERMISSION = "chat.socialspy";
private static void permissions() { private static void permissions() {
SERVERMUTEPERMISSION = getString("permissions.server-mute", SERVERMUTEPERMISSION); SERVERMUTEPERMISSION = getString("permissions.server-mute", SERVERMUTEPERMISSION);
SPYPERMISSION = getString("permissions.spy-permission", SPYPERMISSION); SPYPERMISSION = getString("permissions.spy-permission", SPYPERMISSION);
@ -409,6 +427,7 @@ public final class Config {
public static String DATABASE = "database"; public static String DATABASE = "database";
public static String USERNAME = "root"; public static String USERNAME = "root";
public static String PASSWORD = "root"; public static String PASSWORD = "root";
private static void database() { private static void database() {
IP = getString("database.ip", IP); IP = getString("database.ip", IP);
PORT = getString("database.port", PORT); PORT = getString("database.port", PORT);
@ -418,6 +437,7 @@ public final class Config {
} }
public static String NOTIFICATIONFORMAT = "<red>[<prefix>] <displayname> <target> <input>"; public static String NOTIFICATIONFORMAT = "<red>[<prefix>] <displayname> <target> <input>";
private static void notificationSettings() { private static void notificationSettings() {
NOTIFICATIONFORMAT = getString("settings.blockedmessage-notification", NOTIFICATIONFORMAT); NOTIFICATIONFORMAT = getString("settings.blockedmessage-notification", NOTIFICATIONFORMAT);
} }
@ -431,6 +451,7 @@ public final class Config {
public static String mailSent = "<green>Successfully send mail to <player_name></green>: <#2e8b57><message></#2e8b57>"; public static String mailSent = "<green>Successfully send mail to <player_name></green>: <#2e8b57><message></#2e8b57>";
public static List<String> mailCommandAlias = new ArrayList<>(); public static List<String> mailCommandAlias = new ArrayList<>();
public static int mailDisplayDelay = 5; public static int mailDisplayDelay = 5;
private static void mailSettings() { private static void mailSettings() {
mailHeader = getString("settings.mail.header", mailHeader); mailHeader = getString("settings.mail.header", mailHeader);
mailBody = getString("settings.mail.message", mailBody); mailBody = getString("settings.mail.message", mailBody);
@ -445,6 +466,7 @@ public final class Config {
public static HashMap<String, Long> serverChannelId = new HashMap<>(); 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_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_TOO_SHORT = "<red>Please ensure your report is descriptive. We require at least 3 words per report</red>";
private static void loadChannelIds() { private static void loadChannelIds() {
serverChannelId.clear(); serverChannelId.clear();
serverChannelId.put("general", getLong("discord-channel-id.general", (long) -1)); serverChannelId.put("general", getLong("discord-channel-id.general", (long) -1));
@ -452,8 +474,9 @@ public final class Config {
Map<Object, ? extends ConfigurationNode> objectMap = node.childrenMap(); Map<Object, ? extends ConfigurationNode> objectMap = node.childrenMap();
for (Object o : objectMap.keySet()) { for (Object o : objectMap.keySet()) {
String key = (String) o; String key = (String) o;
if (key.equalsIgnoreCase("general")) if (key.equalsIgnoreCase("general")) {
continue; continue;
}
ConfigurationNode configurationNode = objectMap.get(o); ConfigurationNode configurationNode = objectMap.get(o);
long channelId = configurationNode.getLong(); long channelId = configurationNode.getLong();
serverChannelId.put(key.toLowerCase(), channelId); serverChannelId.put(key.toLowerCase(), channelId);
@ -478,6 +501,7 @@ public final class Config {
public static String HELP_REPORT = "<red>/report <message></red>"; 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() { private static void loadMessages() {
HELP_REPORT = getString("settings.mail.mail-sent", HELP_REPORT); HELP_REPORT = getString("settings.mail.mail-sent", HELP_REPORT);
FIRST_JOIN = getString("settings.first-join.message", FIRST_JOIN); FIRST_JOIN = getString("settings.first-join.message", FIRST_JOIN);
@ -486,6 +510,7 @@ public final class Config {
public static String EMOTELIST_HEADER = "<bold>Available Chat Emotes</bold><newline>"; 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_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() { private static void emoteListCommand() {
EMOTELIST_HEADER = getString("commands.emotelist.header", EMOTELIST_HEADER); EMOTELIST_HEADER = getString("commands.emotelist.header", EMOTELIST_HEADER);
EMOTELIST_ITEM = getString("commands.emotelist.item", EMOTELIST_ITEM); EMOTELIST_ITEM = getString("commands.emotelist.item", EMOTELIST_ITEM);
@ -521,6 +546,7 @@ public final class Config {
public static List<String> NICK_BLOCKED_COLOR_CODESLIST = new ArrayList<>(); public static List<String> NICK_BLOCKED_COLOR_CODESLIST = new ArrayList<>();
public static List<String> NICK_ALLOWED_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() { private static void nicknameSettings() {
NICK_CHANGED = getString("nicknames.messages.nick-changed", NICK_CHANGED); NICK_CHANGED = getString("nicknames.messages.nick-changed", NICK_CHANGED);
NICK_NOT_CHANGED = getString("nicknames.messages.nick-not-changed", NICK_NOT_CHANGED); NICK_NOT_CHANGED = getString("nicknames.messages.nick-not-changed", NICK_NOT_CHANGED);

43
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.database.Queries;
import com.alttd.chat.objects.channels.Channel; import com.alttd.chat.objects.channels.Channel;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.ComponentLike;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -13,20 +13,20 @@ import java.util.stream.Collectors;
public class ChatUser { public class ChatUser {
private final UUID uuid; // player uuid private final UUID uuid; // player uuid
private int partyId; // the party they are in private int partyId; // the party they are in
private Channel toggledChannel; private final 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 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 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 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 prefix; // doesn't need saving, we get this from luckperms // 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 staffPrefix; // doesn't need saving, we get this from luckperms
// private Component prefixAll; // doesn't need saving, we get this from luckperms // private Component prefixAll; // doesn't need saving, we get this from luckperms
//private boolean toggleGc; // should be saved, this toggles if the player can see and use global chat //private boolean toggleGc; // should be saved, this toggles if the player can see and use global chat
private String replyTarget; // reply target for use in /msg i don't mind setting this to null on login, feedback? private String replyTarget; // reply target for use in /msg i don't mind setting this to null on login, feedback?
private String replyContinueTarget; // reply target for use in /c 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 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 boolean spy;
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 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 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> 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 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 boolean isMuted; private boolean isMuted;
public ChatUser(UUID uuid, int partyId, Channel toggledChannel) { public ChatUser(UUID uuid, int partyId, Channel toggledChannel) {
@ -40,10 +40,10 @@ public class ChatUser {
} }
setDisplayName(name); setDisplayName(name);
// prefix = Utility.getPrefix(uuid, true); // TODO we need to update this, so cache and update when needed or always request it? // prefix = Utility.getPrefix(uuid, true); // TODO we need to update this, so cache and update when needed or always request it?
// staffPrefix = Utility.getStaffPrefix(uuid); // staffPrefix = Utility.getStaffPrefix(uuid);
// //
// prefixAll = Utility.getPrefix(uuid, false); // prefixAll = Utility.getPrefix(uuid, false);
replyTarget = ""; replyTarget = "";
replyContinueTarget = ""; replyContinueTarget = "";
@ -71,12 +71,7 @@ public class ChatUser {
return toggledChannel; return toggledChannel;
} }
public void setToggledChannel(Channel channel) { public ComponentLike getDisplayName() {
toggledChannel = channel;
Queries.setToggledChannel(toggledChannel, uuid); //TODO: Async pls - no CompleteableFuture<>!
}
public Component getDisplayName() {
return displayName; return displayName;
} }
@ -84,17 +79,17 @@ public class ChatUser {
this.displayName = Utility.applyColor(displayName); this.displayName = Utility.applyColor(displayName);
} }
public Component getPrefix() { public ComponentLike getPrefix() {
//return prefix; //return prefix;
return Utility.getPrefix(uuid, true); // No longer cache this data return Utility.getPrefix(uuid, true); // No longer cache this data
} }
public Component getStaffPrefix() { public ComponentLike getStaffPrefix() {
//return staffPrefix; //return staffPrefix;
return Utility.getStaffPrefix(uuid); return Utility.getStaffPrefix(uuid);
} }
public Component getPrefixAll() { public ComponentLike getPrefixAll() {
//return prefixAll; //return prefixAll;
return Utility.getPrefix(uuid, false); return Utility.getPrefix(uuid, false);
} }
@ -145,10 +140,6 @@ public class ChatUser {
return ignoredBy; return ignoredBy;
} }
public void addIgnoredBy(UUID uuid) {
ignoredBy.add(uuid);
}
public long getGcCooldown() { public long getGcCooldown() {
return gcCooldown; return gcCooldown;
} }

14
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.managers.RegexManager;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component; 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.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver; import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import org.bukkit.Bukkit;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
@ -16,7 +16,7 @@ public class EmoteList {
public static final Map<UUID, EmoteList> emoteLists = new HashMap<>(); public static final Map<UUID, EmoteList> emoteLists = new HashMap<>();
public static final int pageSize = 7; public static final int pageSize = 7;
// public static int pages = RegexManager.getEmoteFilters().size() / pageSize;// TODO reload this when config is reloaded. // public static int pages = RegexManager.getEmoteFilters().size() / pageSize;// TODO reload this when config is reloaded.
public static EmoteList getEmoteList(UUID uuid) { public static EmoteList getEmoteList(UUID uuid) {
synchronized (emoteLists) { synchronized (emoteLists) {
@ -25,22 +25,23 @@ public class EmoteList {
} }
private int page; private int page;
public Component showEmotePage() {
public ComponentLike showEmotePage() {
int startIndex = page * pageSize; int startIndex = page * pageSize;
int pages = RegexManager.getEmoteFilters().size() / pageSize; int pages = RegexManager.getEmoteFilters().size() / pageSize;
int endIndex = Math.min(startIndex + pageSize, RegexManager.getEmoteFilters().size()); int endIndex = Math.min(startIndex + pageSize, RegexManager.getEmoteFilters().size());
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.unparsed("page", String.valueOf(page)), Placeholder.unparsed("page", String.valueOf(page)),
Placeholder.unparsed("pages", String.valueOf(pages)) Placeholder.unparsed("pages", String.valueOf(pages))
); );
Component list = Utility.parseMiniMessage(Config.EMOTELIST_HEADER, placeholders); Component list = Utility.parseMiniMessage(Config.EMOTELIST_HEADER, placeholders).asComponent();
for (int i = startIndex; i < endIndex; i++) { for (int i = startIndex; i < endIndex; i++) {
ChatFilter emote = RegexManager.getEmoteFilters().get(i); ChatFilter emote = RegexManager.getEmoteFilters().get(i);
TagResolver emotes = TagResolver.resolver( TagResolver emotes = TagResolver.resolver(
Placeholder.parsed("regex", emote.getRegex()), Placeholder.parsed("regex", emote.getRegex()),
Placeholder.parsed("emote", emote.getReplacement()) Placeholder.parsed("emote", emote.getReplacement())
); );
list = list.append(Utility.parseMiniMessage(Config.EMOTELIST_ITEM, emotes)); list = list.append(Utility.parseMiniMessage(Config.EMOTELIST_ITEM, emotes));
} }
list = list.append(Utility.parseMiniMessage(Config.EMOTELIST_FOOTER, placeholders)); list = list.append(Utility.parseMiniMessage(Config.EMOTELIST_FOOTER, placeholders));
@ -60,5 +61,4 @@ public class EmoteList {
this.page = Math.max(page - 1, 0); this.page = Math.max(page - 1, 0);
} }
} }

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

@ -3,10 +3,6 @@ package com.alttd.chat.objects;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextReplacementConfig; import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; 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 { public class ModifiableString {
private Component text; 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; package com.alttd.chat.objects;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.ComponentLike;
import java.util.UUID; import java.util.UUID;
public class PartyUser { public class PartyUser {
protected UUID uuid; protected UUID uuid;
protected Component displayName; protected ComponentLike displayName;
protected String playerName; protected String playerName;
public PartyUser(UUID uuid, String displayName, String playerName) { public PartyUser(UUID uuid, String displayName, String playerName) {
this(uuid, Utility.applyColor(displayName), playerName); this(uuid, Utility.applyColor(displayName), playerName);
} }
public PartyUser(UUID uuid, Component displayName, String playerName) { public PartyUser(UUID uuid, ComponentLike displayName, String playerName) {
this.uuid = uuid; this.uuid = uuid;
this.displayName = displayName; this.displayName = displayName;
this.playerName = playerName; this.playerName = playerName;
@ -25,7 +25,7 @@ public class PartyUser {
return uuid; return uuid;
} }
public Component getDisplayName() { public ComponentLike getDisplayName() {
return displayName; return displayName;
} }

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

@ -3,11 +3,11 @@ package com.alttd.chat.util;
import com.alttd.chat.ChatAPI; import com.alttd.chat.ChatAPI;
import com.alttd.chat.config.Config; import com.alttd.chat.config.Config;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.format.TextDecoration; import net.kyori.adventure.text.format.TextDecoration;
import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver; import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags; 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.LuckPerms;
import net.luckperms.api.model.group.Group; import net.luckperms.api.model.group.Group;
import net.luckperms.api.model.user.User; import net.luckperms.api.model.user.User;
@ -16,19 +16,17 @@ import net.luckperms.api.node.Node;
import java.util.*; import java.util.*;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class Utility { public class Utility {
private static final List<String> EMPTY_LIST = new ArrayList<>(); 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?://)?[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_+.~#?&/=]*)");
static final Pattern URL_SCHEME_PATTERN = Pattern.compile("^[a-z][a-z0-9+\\-.]*:");
private static MiniMessage miniMessage = null; private static MiniMessage miniMessage = null;
public static String stringRegen = "\\{#[A-Fa-f0-9]{6}(<)?(>)?}"; public static String stringRegen = "\\{#[A-Fa-f0-9]{6}(<)?(>)?}";
public static HashMap<String, String> colors; public static HashMap<String, String> colors;
private static LegacyComponentSerializer legacySerializer;
static { // this might be in minimessage already? static { // this might be in minimessage already?
colors = new HashMap<>(); colors = new HashMap<>();
colors.put("&0", "<black>"); colors.put("&0", "<black>");
@ -48,41 +46,44 @@ public class Utility {
colors.put("&e", "<yellow>"); colors.put("&e", "<yellow>");
colors.put("&f", "<white>"); colors.put("&f", "<white>");
} }
public static HashMap<String, Pair<TagResolver, List<String>>> formattingPerms = new HashMap<>(); public static HashMap<String, Pair<TagResolver, List<String>>> formattingPerms = new HashMap<>();
static { static {
formattingPerms.put("chat.format.color", formattingPerms.put("chat.format.color",
new Pair<>(StandardTags.color(), colors.values().stream().toList())); new Pair<>(StandardTags.color(), colors.values().stream().toList()));
formattingPerms.put("chat.format.bold", formattingPerms.put("chat.format.bold",
new Pair<>(StandardTags.decorations(TextDecoration.BOLD), List.of("<bold>", "<b>"))); new Pair<>(StandardTags.decorations(TextDecoration.BOLD), List.of("<bold>", "<b>")));
formattingPerms.put("chat.format.italic", formattingPerms.put("chat.format.italic",
new Pair<>(StandardTags.decorations(TextDecoration.ITALIC), List.of("<italic>", "<i>"))); new Pair<>(StandardTags.decorations(TextDecoration.ITALIC), List.of("<italic>", "<i>")));
formattingPerms.put("chat.format.underlined", formattingPerms.put("chat.format.underlined",
new Pair<>(StandardTags.decorations(TextDecoration.UNDERLINED), List.of("<underlined>", "<u>"))); new Pair<>(StandardTags.decorations(TextDecoration.UNDERLINED), List.of("<underlined>", "<u>")));
formattingPerms.put("chat.format.strikethrough", formattingPerms.put("chat.format.strikethrough",
new Pair<>(StandardTags.decorations(TextDecoration.STRIKETHROUGH), List.of("<strikethrough>", "<st>"))); new Pair<>(StandardTags.decorations(TextDecoration.STRIKETHROUGH), List.of("<strikethrough>", "<st>")));
formattingPerms.put("chat.format.obfuscated", formattingPerms.put("chat.format.obfuscated",
new Pair<>(StandardTags.decorations(TextDecoration.OBFUSCATED), List.of("<obfuscated>", "<obf>"))); new Pair<>(StandardTags.decorations(TextDecoration.OBFUSCATED), List.of("<obfuscated>", "<obf>")));
formattingPerms.put("chat.format.gradient", formattingPerms.put("chat.format.gradient",
new Pair<>(StandardTags.gradient(), EMPTY_LIST)); new Pair<>(StandardTags.gradient(), EMPTY_LIST));
formattingPerms.put("chat.format.font", formattingPerms.put("chat.format.font",
new Pair<>(StandardTags.font(), EMPTY_LIST)); new Pair<>(StandardTags.font(), EMPTY_LIST));
formattingPerms.put("chat.format.rainbow", formattingPerms.put("chat.format.rainbow",
new Pair<>(StandardTags.rainbow(), List.of("<rainbow>"))); new Pair<>(StandardTags.rainbow(), List.of("<rainbow>")));
formattingPerms.put("chat.format.hover", formattingPerms.put("chat.format.hover",
new Pair<>(StandardTags.hoverEvent(), EMPTY_LIST)); new Pair<>(StandardTags.hoverEvent(), EMPTY_LIST));
formattingPerms.put("chat.format.click", formattingPerms.put("chat.format.click",
new Pair<>(StandardTags.clickEvent(), EMPTY_LIST)); new Pair<>(StandardTags.clickEvent(), EMPTY_LIST));
formattingPerms.put("chat.format.transition", formattingPerms.put("chat.format.transition",
new Pair<>(StandardTags.transition(), EMPTY_LIST)); new Pair<>(StandardTags.transition(), EMPTY_LIST));
formattingPerms.put("chat.format.reset", formattingPerms.put("chat.format.reset",
new Pair<>(StandardTags.reset(), List.of("<reset>", "<r>"))); new Pair<>(StandardTags.reset(), List.of("<reset>", "<r>")));
formattingPerms.put("chat.format.newline", formattingPerms.put("chat.format.newline",
new Pair<>(StandardTags.newline(), List.of("<newline>"))); new Pair<>(StandardTags.newline(), List.of("<newline>")));
} }
public static String parseColors(String message) { public static String parseColors(String message) {
if (message == null) return ""; if (message == null) {
return "";
}
// split string in sections and check those vs looping hashmap?:/ // split string in sections and check those vs looping hashmap?:/
// think this is better, but will check numbers on this // think this is better, but will check numbers on this
for (String key : colors.keySet()) { for (String key : colors.keySet()) {
@ -93,15 +94,17 @@ public class Utility {
return message; return message;
} }
public static Component getPrefix(UUID uuid, boolean single) { public static ComponentLike getPrefix(UUID uuid, boolean single) {
StringBuilder prefix = new StringBuilder(); StringBuilder prefix = new StringBuilder();
LuckPerms luckPerms = ChatAPI.get().getLuckPerms(); LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid); User user = luckPerms.getUserManager().getUser(uuid);
List<String> prefixGroups = Config.PREFIXGROUPS; List<String> prefixGroups = Config.PREFIXGROUPS;
if(user == null) return Component.empty(); if (user == null) {
if(!single) { return Component.empty();
}
if (!single) {
Collection<Group> inheritedGroups = user.getInheritedGroups(user.getQueryOptions()); Collection<Group> inheritedGroups = user.getInheritedGroups(user.getQueryOptions());
if(inheritedGroups.stream().map(Group::getName).collect(Collectors.toList()).contains("eventleader")) { if (inheritedGroups.stream().anyMatch(group -> group.getName().equals("eventleader"))) {
prefixGroups.remove("eventteam"); // hardcoded for now, new prefix system would load this from config prefixGroups.remove("eventteam"); // hardcoded for now, new prefix system would load this from config
} }
inheritedGroups.stream() inheritedGroups.stream()
@ -113,21 +116,23 @@ public class Utility {
}); });
} }
prefix.append(getUserPrefix(user)); prefix.append(getUserPrefix(user));
// prefix.append(user.getCachedData().getMetaData().getPrefix());
return applyColor(prefix.toString()); return applyColor(prefix.toString());
} }
public static Component getStaffPrefix(UUID uuid) { public static ComponentLike getStaffPrefix(UUID uuid) {
StringBuilder prefix = new StringBuilder(); StringBuilder prefix = new StringBuilder();
LuckPerms luckPerms = ChatAPI.get().getLuckPerms(); LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid); User user = luckPerms.getUserManager().getUser(uuid);
if(user == null) return Component.empty(); if (user == null) {
if(user.getCachedData().getPermissionData().checkPermission("group." + Config.MINIMIUMSTAFFRANK).asBoolean()) { return Component.empty();
}
if (user.getCachedData().getPermissionData().checkPermission("group." + Config.MINIMIUMSTAFFRANK).asBoolean()) {
Group group = luckPerms.getGroupManager().getGroup(user.getPrimaryGroup()); Group group = luckPerms.getGroupManager().getGroup(user.getPrimaryGroup());
if(group != null) if (group != null) {
prefix.append(getGroupPrefix(group)); prefix.append(getGroupPrefix(group));
// prefix.append(group.getCachedData().getMetaData().getPrefix()); }
// prefix.append(group.getCachedData().getMetaData().getPrefix());
} }
return applyColor(prefix.toString()); return applyColor(prefix.toString());
} }
@ -138,26 +143,32 @@ public class Utility {
if (group == null) { if (group == null) {
return ""; return "";
} }
return ChatAPI.get().getPrefixes().get(group.getName()).replace("<prefix>", user.getCachedData().getMetaData().getPrefix()); String prefix = user.getCachedData().getMetaData().getPrefix();
} if (prefix == null) {
ALogger.warn("User " + user.getUsername() + " has no prefix set!");
public static String getGroupPrefix(String groupName) {
Group group = ChatAPI.get().getLuckPerms().getGroupManager().getGroup(groupName);
if (group == null) {
return ""; return "";
} }
return getGroupPrefix(group); return ChatAPI.get().getPrefixes().get(group.getName()).replace("<prefix>", prefix);
} }
public static String getGroupPrefix(Group group) { public static String getGroupPrefix(Group group) {
return ChatAPI.get().getPrefixes().get(group.getName()).replace("<prefix>", group.getCachedData().getMetaData().getPrefix()); 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);
} }
public static String getDisplayName(UUID uuid, String playerName) { public static String getDisplayName(UUID uuid, String playerName) {
if (!playerName.isBlank()) return playerName; if (!playerName.isBlank()) {
return playerName;
}
LuckPerms luckPerms = ChatAPI.get().getLuckPerms(); LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid); User user = luckPerms.getUserManager().getUser(uuid);
if(user == null) return ""; if (user == null) {
return "";
}
return user.getUsername(); return user.getUsername();
} }
@ -165,20 +176,22 @@ public class Utility {
ChatAPI.get().getLuckPerms().getUserManager().modifyUser(uuid, user -> { ChatAPI.get().getLuckPerms().getUserManager().modifyUser(uuid, user -> {
// Add the permission // Add the permission
user.data().add(Node.builder(permission) user.data().add(Node.builder(permission)
.value(!user.getCachedData().getPermissionData().checkPermission(permission).asBoolean()).build()); .value(!user.getCachedData().getPermissionData().checkPermission(permission).asBoolean()).build());
}); });
} }
public static boolean hasPermission(UUID uuid, String permission) { public static boolean hasPermission(UUID uuid, String permission) {
LuckPerms luckPerms = ChatAPI.get().getLuckPerms(); LuckPerms luckPerms = ChatAPI.get().getLuckPerms();
User user = luckPerms.getUserManager().getUser(uuid); User user = luckPerms.getUserManager().getUser(uuid);
if(user == null) return false; if (user == null) {
return false;
}
return user.getCachedData().getPermissionData().checkPermission(permission).asBoolean(); return user.getCachedData().getPermissionData().checkPermission(permission).asBoolean();
} }
public static Component applyColor(String message) { public static ComponentLike applyColor(String message) {
String hexColor1 = ""; String hexColor1 = "";
String hexColor2 = ""; String hexColor2;
StringBuilder stringBuilder = new StringBuilder(); StringBuilder stringBuilder = new StringBuilder();
message = parseColors(message); message = parseColors(message);
boolean startsWithColor = false; boolean startsWithColor = false;
@ -196,7 +209,7 @@ public class Utility {
for (String s : split) { for (String s : split) {
nextIndex += s.length(); nextIndex += s.length();
int tmp = message.indexOf("}", nextIndex); int tmp = message.indexOf("}", nextIndex);
if (tmp < message.length() && tmp>=0) { if (tmp < message.length() && tmp >= 0) {
list.add(message.substring(nextIndex, tmp + 1)); list.add(message.substring(nextIndex, tmp + 1));
nextIndex = tmp + 1; nextIndex = tmp + 1;
} }
@ -220,7 +233,7 @@ public class Utility {
} else if (bigger || lesser) { } else if (bigger || lesser) {
hexColor2 = s.substring(1, s.length() - 2); hexColor2 = s.substring(1, s.length() - 2);
} else { } else {
hexColor2 = s.substring(1, s.length() -1); hexColor2 = s.substring(1, s.length() - 1);
} }
if (firstLoop) { if (firstLoop) {
@ -241,12 +254,12 @@ public class Utility {
lastColorMatters = bigger; lastColorMatters = bigger;
i++; i++;
} }
if (split.length > i){ if (split.length > i) {
stringBuilder.append("<").append(hexColor1).append(">").append(split[i]); stringBuilder.append("<").append(hexColor1).append(">").append(split[i]);
} }
} }
return stringBuilder.length() == 0 ? Utility.parseMiniMessage(message) return stringBuilder.isEmpty() ? Utility.parseMiniMessage(message)
: Utility.parseMiniMessage(stringBuilder.toString()); : Utility.parseMiniMessage(stringBuilder.toString());
} }
public static boolean checkNickBrightEnough(String nickname) { public static boolean checkNickBrightEnough(String nickname) {
@ -294,10 +307,9 @@ public class Utility {
Matcher matcher = DEFAULT_URL_PATTERN.matcher(message); Matcher matcher = DEFAULT_URL_PATTERN.matcher(message);
while (matcher.find()) { while (matcher.find()) {
String url = matcher.group(); String url = matcher.group();
String displayUrl = url;
String urlFormat = Config.URLFORMAT; String urlFormat = Config.URLFORMAT;
message = message.replace(url, urlFormat message = message.replace(url, urlFormat
.replaceAll("<url>", "<u>" + displayUrl + "</u>") .replaceAll("<url>", "<u>" + url + "</u>")
.replaceAll("<clickurl>", formatUrl(url))); .replaceAll("<clickurl>", formatUrl(url)));
} }
return message; return message;
@ -310,11 +322,11 @@ public class Utility {
return "https://" + url; return "https://" + url;
} }
public static Component parseMiniMessage(String message) { public static ComponentLike parseMiniMessage(String message) {
return getMiniMessage().deserialize(message); return getMiniMessage().deserialize(message);
} }
public static Component parseMiniMessage(String message, TagResolver placeholders) { public static ComponentLike parseMiniMessage(String message, TagResolver placeholders) {
if (placeholders == null) { if (placeholders == null) {
return getMiniMessage().deserialize(message); return getMiniMessage().deserialize(message);
} else { } else {
@ -322,7 +334,7 @@ public class Utility {
} }
} }
public static Component parseMiniMessage(String message, TagResolver ... placeholders) { public static ComponentLike parseMiniMessage(String message, TagResolver... placeholders) {
if (placeholders == null) { if (placeholders == null) {
return getMiniMessage().deserialize(message); return getMiniMessage().deserialize(message);
} else { } else {
@ -335,7 +347,9 @@ public class Utility {
} }
public static MiniMessage getMiniMessage() { public static MiniMessage getMiniMessage() {
if (miniMessage == null) miniMessage = MiniMessage.miniMessage(); if (miniMessage == null) {
miniMessage = MiniMessage.miniMessage();
}
return miniMessage; return miniMessage;
} }

3
build.gradle.kts
View File

@ -1,6 +1,7 @@
plugins { plugins {
`java-library` `java-library`
id("io.github.goooler.shadow") version "8.1.8" id("io.github.goooler.shadow") version "8.1.8"
id("com.github.ben-manes.versions") version "0.52.0"
} }
allprojects { allprojects {
@ -67,4 +68,4 @@ tasks {
jar { jar {
enabled = false enabled = false
} }
} }

11
galaxy/build.gradle.kts
View File

@ -5,11 +5,12 @@ plugins {
dependencies { dependencies {
implementation(project(":api")) // API implementation(project(":api")) // API
// compileOnly("com.alttd:Galaxy-API:1.21-R0.1-SNAPSHOT") // Galaxy compileOnly("com.alttd.cosmos:cosmos-api:1.21.6-R0.1-SNAPSHOT") {
compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT") isChanging = true
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("com.gitlab.ruany:LiteBansAPI:0.6.1") // move to proxy
compileOnly("net.luckperms:api:5.3") // Luckperms 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
} }
tasks { tasks {

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

@ -16,13 +16,10 @@ import com.alttd.chat.util.ServerName;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.PluginCommand;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.plugin.java.JavaPlugin;
import java.io.File; import java.util.Objects;
import java.util.List;
public class ChatPlugin extends JavaPlugin { public class ChatPlugin extends JavaPlugin {
@ -31,7 +28,6 @@ public class ChatPlugin extends JavaPlugin {
private ChatAPI chatAPI; private ChatAPI chatAPI;
private ChatHandler chatHandler; private ChatHandler chatHandler;
private String messageChannel;
private ServerConfig serverConfig; private ServerConfig serverConfig;
@Override @Override
@ -44,7 +40,7 @@ public class ChatPlugin extends JavaPlugin {
serverConfig = new ServerConfig(ServerName.getServerName()); serverConfig = new ServerConfig(ServerName.getServerName());
ChatLogHandler chatLogHandler = ChatLogHandler.getInstance(true); ChatLogHandler chatLogHandler = ChatLogHandler.getInstance(true);
registerListener(new PlayerListener(serverConfig), new ChatListener(chatLogHandler), new BookListener(), new ShutdownListener(chatLogHandler, this)); registerListener(new PlayerListener(serverConfig), new ChatListener(chatLogHandler), new BookListener(), new ShutdownListener(chatLogHandler, this));
if(serverConfig.GLOBALCHAT) { if (serverConfig.GLOBALCHAT) {
registerCommand("globalchat", new GlobalChat()); registerCommand("globalchat", new GlobalChat());
registerCommand("toggleglobalchat", new ToggleGlobalChat()); registerCommand("toggleglobalchat", new ToggleGlobalChat());
} }
@ -56,7 +52,6 @@ public class ChatPlugin extends JavaPlugin {
registerCommand("muteserver", new MuteServer()); registerCommand("muteserver", new MuteServer());
registerCommand("spy", new Spy()); registerCommand("spy", new Spy());
registerCommand("chatclear", new ChatClear()); registerCommand("chatclear", new ChatClear());
// registerCommand("chatparty", new ChatParty());
registerCommand("p", new PartyChat()); registerCommand("p", new PartyChat());
registerCommand("emotes", new Emotes()); registerCommand("emotes", new Emotes());
for (Channel channel : Channel.getChannels()) { for (Channel channel : Channel.getChannels()) {
@ -66,7 +61,7 @@ public class ChatPlugin extends JavaPlugin {
this.getServer().getCommandMap().register(channel.getChannelName().toLowerCase(), new ChatChannel(customChannel)); this.getServer().getCommandMap().register(channel.getChannelName().toLowerCase(), new ChatChannel(customChannel));
} }
messageChannel = Config.MESSAGECHANNEL; String messageChannel = Config.MESSAGECHANNEL;
getServer().getMessenger().registerOutgoingPluginChannel(this, messageChannel); getServer().getMessenger().registerOutgoingPluginChannel(this, messageChannel);
getServer().getMessenger().registerIncomingPluginChannel(this, messageChannel, new PluginMessage()); getServer().getMessenger().registerIncomingPluginChannel(this, messageChannel, new PluginMessage());
@ -88,23 +83,13 @@ public class ChatPlugin extends JavaPlugin {
} }
public void registerCommand(String commandName, CommandExecutor commandExecutor) { public void registerCommand(String commandName, CommandExecutor commandExecutor) {
getCommand(commandName).setExecutor(commandExecutor); Objects.requireNonNull(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() { public static ChatPlugin getInstance() {
return instance; return instance;
} }
public ChatAPI getChatAPI() {
return chatAPI;
}
public ChatHandler getChatHandler() { public ChatHandler getChatHandler() {
return chatHandler; return chatHandler;
} }
@ -125,7 +110,7 @@ public class ChatPlugin extends JavaPlugin {
chatAPI.reloadConfig(); chatAPI.reloadConfig();
chatAPI.reloadChatFilters(); chatAPI.reloadChatFilters();
serverConfig = new ServerConfig(ServerName.getServerName()); serverConfig = new ServerConfig(ServerName.getServerName());
Bukkit.broadcast(Utility.parseMiniMessage("Reloaded ChatPlugin Config."), "command.chat.reloadchat"); Bukkit.broadcast(Utility.parseMiniMessage("Reloaded ChatPlugin Config.").asComponent(), "command.chat.reloadchat");
ALogger.info("Reloaded ChatPlugin config."); ALogger.info("Reloaded ChatPlugin config.");
} }
} }

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

@ -11,14 +11,16 @@ import org.bukkit.command.defaults.BukkitCommand;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import java.util.*; import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ChatChannel extends BukkitCommand { public class ChatChannel extends BukkitCommand {
CustomChannel channel; CustomChannel channel;
String command; String command;
ToggleableForCustomChannel toggleableForCustomChannel; ToggleableForCustomChannel toggleableForCustomChannel;
private static List<ChatChannel> activeCommands = new ArrayList<>(); private static final List<ChatChannel> activeCommands = new ArrayList<>();
public ChatChannel(CustomChannel channel) { public ChatChannel(CustomChannel channel) {
super(channel.getChannelName().toLowerCase()); super(channel.getChannelName().toLowerCase());
@ -33,15 +35,15 @@ public class ChatChannel extends BukkitCommand {
@Override @Override
public boolean execute(@NotNull CommandSender sender, @NotNull String command, @NotNull String[] args) { public boolean execute(@NotNull CommandSender sender, @NotNull String command, @NotNull String[] args) {
if(!(sender instanceof Player player)) { // must be a player if (!(sender instanceof Player player)) { // must be a player
return true; return true;
} }
if(args.length == 0 && player.hasPermission(channel.getPermission())) { if (args.length == 0 && player.hasPermission(channel.getPermission())) {
player.sendRichMessage(Config.CUSTOM_CHANNEL_TOGGLED, TagResolver.resolver( player.sendRichMessage(Config.CUSTOM_CHANNEL_TOGGLED, TagResolver.resolver(
Placeholder.unparsed("channel", channel.getChannelName()), Placeholder.unparsed("channel", channel.getChannelName()),
Placeholder.component("status", toggleableForCustomChannel.toggle(player.getUniqueId()) Placeholder.component("status", toggleableForCustomChannel.toggle(player.getUniqueId())
? Config.TOGGLED_ON : Config.TOGGLED_OFF))); ? Config.TOGGLED_ON : Config.TOGGLED_OFF)));
return false; return false;
} }

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

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

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

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

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

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

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

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

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

@ -8,15 +8,18 @@ import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class Message implements CommandExecutor { public class Message implements CommandExecutor {
@Override @Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
if(!(sender instanceof Player player)) { if (!(sender instanceof Player player)) {
return true; 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()); ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
user.setReplyContinueTarget(args[0]); user.setReplyContinueTarget(args[0]);

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

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

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

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

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

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

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

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

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

@ -15,6 +15,7 @@ import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataOutput; import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams; import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.TextReplacementConfig; import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.format.NamedTextColor; import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.MiniMessage;
@ -28,16 +29,17 @@ import org.bukkit.entity.Entity;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import java.util.*; import java.util.List;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream; import java.util.stream.Stream;
public class ChatHandler { public class ChatHandler {
private final ChatPlugin plugin; private final ChatPlugin plugin;
private final Component GCNOTENABLED; private final ComponentLike GCNOTENABLED;
public ChatHandler() { public ChatHandler() {
plugin = ChatPlugin.getInstance(); plugin = ChatPlugin.getInstance();
@ -45,68 +47,68 @@ public class ChatHandler {
} }
public void continuePrivateMessage(Player player, String target, String message) { public void continuePrivateMessage(Player player, String target, String message) {
// ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); // ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
// user.setReplyTarget(target); // user.setReplyTarget(target);
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.component("message", parseMessageContent(player, message)), Placeholder.component("message", parseMessageContent(player, message)),
Placeholder.component("sendername", player.name()), Placeholder.component("sendername", player.name()),
Placeholder.parsed("receivername", target) Placeholder.parsed("receivername", target)
); );
Component component = Utility.parseMiniMessage("<message>", placeholders); ComponentLike component = Utility.parseMiniMessage("<message>", placeholders);
ModifiableString modifiableString = new ModifiableString(component); ModifiableString modifiableString = new ModifiableString(component.asComponent());
// todo a better way for this // todo a better way for this
if(!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "privatemessage")) { if (!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "privatemessage")) {
GalaxyUtility.sendBlockedNotification("DM Language", GalaxyUtility.sendBlockedNotification("DM Language",
player, player,
Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())), Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
target); target);
return; // the message was blocked return; // the message was blocked
} }
component = modifiableString.component(); component = modifiableString.component();
sendPrivateMessage(player, target, "privatemessage", component); sendPrivateMessage(player, target, "privatemessage", component.asComponent());
Component spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders); ComponentLike spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
for(Player pl : Bukkit.getOnlinePlayers()) { for (Player pl : Bukkit.getOnlinePlayers()) {
if(pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) { if (pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
pl.sendMessage(spymessage); pl.sendMessage(spymessage);
} }
} }
} }
public void privateMessage(Player player, String target, String message) { public void privateMessage(Player player, String target, String message) {
// ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); // ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
// user.setReplyTarget(target); // user.setReplyTarget(target);
Component messageComponent = parseMessageContent(player, message); Component messageComponent = parseMessageContent(player, message);
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.component("message", messageComponent), Placeholder.component("message", messageComponent),
Placeholder.component("sendername", player.name()), Placeholder.component("sendername", player.name()),
Placeholder.parsed("receivername", target) Placeholder.parsed("receivername", target)
); );
ModifiableString modifiableString = new ModifiableString(messageComponent); ModifiableString modifiableString = new ModifiableString(messageComponent);
// todo a better way for this // todo a better way for this
if(!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "privatemessage")) { if (!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "privatemessage")) {
GalaxyUtility.sendBlockedNotification("DM Language", GalaxyUtility.sendBlockedNotification("DM Language",
player, player,
Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())), Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
target); target);
return; // the message was blocked return; // the message was blocked
} }
messageComponent = modifiableString.component(); messageComponent = modifiableString.component();
// Component component = Utility.parseMiniMessage("<message>", placeholders) // Component component = Utility.parseMiniMessage("<message>", placeholders)
// .replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand())).build()); // .replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand())).build());
sendPrivateMessage(player, target, "privatemessage", messageComponent); sendPrivateMessage(player, target, "privatemessage", messageComponent);
Component spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders); ComponentLike spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
for(Player pl : Bukkit.getOnlinePlayers()) { for (Player pl : Bukkit.getOnlinePlayers()) {
if(pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) { if (pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
pl.sendMessage(spymessage); pl.sendMessage(spymessage);
} }
} }
@ -114,7 +116,7 @@ public class ChatHandler {
public void globalChat(Player player, String message) { public void globalChat(Player player, String message) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
if(!Utility.hasPermission(player.getUniqueId(), Config.GCPERMISSION)) { if (!Utility.hasPermission(player.getUniqueId(), Config.GCPERMISSION)) {
player.sendMessage(GCNOTENABLED);// GC IS OFF INFORM THEM ABOUT THIS and cancel player.sendMessage(GCNOTENABLED);// GC IS OFF INFORM THEM ABOUT THIS and cancel
return; return;
} }
@ -124,29 +126,29 @@ public class ChatHandler {
} }
long timeLeft = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis() - user.getGcCooldown()); 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 if (timeLeft <= Config.GCCOOLDOWN && !player.hasPermission("chat.globalchat.cooldownbypass")) { // player is on cooldown and should wait x seconds
player.sendMessage(Utility.parseMiniMessage(Config.GCONCOOLDOWN, Placeholder.parsed("cooldown", Config.GCCOOLDOWN-timeLeft+""))); player.sendRichMessage(Config.GCONCOOLDOWN, Placeholder.parsed("cooldown", Config.GCCOOLDOWN - timeLeft + ""));
return; return;
} }
Component senderName = user.getDisplayName(); ComponentLike senderName = user.getDisplayName();
Component prefix = user.getPrefix(); ComponentLike prefix = user.getPrefix();
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName), Placeholder.component("sender", senderName),
Placeholder.component("prefix", prefix), Placeholder.component("prefix", prefix),
Placeholder.component("message", parseMessageContent(player, message)), Placeholder.component("message", parseMessageContent(player, message)),
Placeholder.parsed("server", ServerName.getServerName()) Placeholder.parsed("server", ServerName.getServerName())
); );
Component component = Utility.parseMiniMessage(Config.GCFORMAT, placeholders); Component component = Utility.parseMiniMessage(Config.GCFORMAT, placeholders).asComponent();
ModifiableString modifiableString = new ModifiableString(component); ModifiableString modifiableString = new ModifiableString(component);
// todo a better way for this // todo a better way for this
if (!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "globalchat")) { if (!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, "globalchat")) {
GalaxyUtility.sendBlockedNotification("GC Language", GalaxyUtility.sendBlockedNotification("GC Language",
player, player,
Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())), Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
""); "");
return; // the message was blocked return; // the message was blocked
} }
component = modifiableString.component(); component = modifiableString.component();
@ -157,7 +159,7 @@ public class ChatHandler {
public void chatChannel(Player player, CustomChannel channel, String message) { public void chatChannel(Player player, CustomChannel channel, String message) {
if (!player.hasPermission(channel.getPermission())) { if (!player.hasPermission(channel.getPermission())) {
player.sendMessage(Utility.parseMiniMessage("<red>You don't have permission to use this channel.</red>")); player.sendRichMessage("<red>You don't have permission to use this channel.</red>");
return; return;
} }
@ -167,22 +169,22 @@ public class ChatHandler {
} }
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
Component senderName = user.getDisplayName(); ComponentLike senderName = user.getDisplayName();
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName), Placeholder.component("sender", senderName),
Placeholder.component("message", parseMessageContent(player, message)), Placeholder.component("message", parseMessageContent(player, message)),
Placeholder.parsed("server", ServerName.getServerName()), Placeholder.parsed("server", ServerName.getServerName()),
Placeholder.parsed("channel", channel.getChannelName()) Placeholder.parsed("channel", channel.getChannelName())
); );
Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders); Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders).asComponent();
ModifiableString modifiableString = new ModifiableString(component); ModifiableString modifiableString = new ModifiableString(component);
if(!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, channel.getChannelName())) { if (!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, channel.getChannelName())) {
GalaxyUtility.sendBlockedNotification(channel.getChannelName() + " Language", GalaxyUtility.sendBlockedNotification(channel.getChannelName() + " Language",
player, player,
Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())), Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
""); "");
ALogger.info("Refusing to send blocked chat message"); ALogger.info("Refusing to send blocked chat message");
return; return;
} }
@ -203,49 +205,48 @@ public class ChatHandler {
out.writeUTF(message); out.writeUTF(message);
out.writeUTF(GsonComponentSerializer.gson().serialize( out.writeUTF(GsonComponentSerializer.gson().serialize(
itemComponent(player.getInventory().getItemInMainHand()) itemComponent(player.getInventory().getItemInMainHand())
)); ));
player.sendPluginMessage(plugin, Config.MESSAGECHANNEL, out.toByteArray()); player.sendPluginMessage(plugin, Config.MESSAGECHANNEL, out.toByteArray());
// if (isMuted(player, message, "[" + party.getPartyName() + " Muted] ")) return;
// if (isMuted(player, message, "[" + party.getPartyName() + " Muted] ")) return; //
// // ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
// ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); // Component senderName = user.getDisplayName();
// Component senderName = user.getDisplayName(); //
// // String updatedMessage = RegexManager.replaceText(player.getName(), player.getUniqueId(), message);
// String updatedMessage = RegexManager.replaceText(player.getName(), player.getUniqueId(), message); // if(updatedMessage == null) {
// if(updatedMessage == null) { // GalaxyUtility.sendBlockedNotification("Party Language", player, message, "");
// GalaxyUtility.sendBlockedNotification("Party Language", player, message, ""); // return; // the message was blocked
// return; // the message was blocked // }
// } //
// // if(!player.hasPermission("chat.format")) {
// if(!player.hasPermission("chat.format")) { // updatedMessage = Utility.stripTokens(updatedMessage);
// updatedMessage = Utility.stripTokens(updatedMessage); // }
// } //
// // if(updatedMessage.contains("[i]")) updatedMessage = updatedMessage.replaceFirst("[i]", "<item>");
// if(updatedMessage.contains("[i]")) updatedMessage = updatedMessage.replaceFirst("[i]", "<item>"); //
// // updatedMessage = Utility.formatText(updatedMessage);
// updatedMessage = Utility.formatText(updatedMessage); //
// // List<Placeholder> Placeholders = new ArrayList<>(List.of(
// List<Placeholder> Placeholders = new ArrayList<>(List.of( // Placeholder.miniMessage("sender", senderName),
// Placeholder.miniMessage("sender", senderName), // Placeholder.miniMessage("sendername", senderName),
// Placeholder.miniMessage("sendername", senderName), // Placeholder.miniMessage("partyname", party.getPartyName()),
// Placeholder.miniMessage("partyname", party.getPartyName()), // Placeholder.miniMessage("message", updatedMessage),
// Placeholder.miniMessage("message", updatedMessage), // Placeholder.miniMessage("server", Bukkit.getServerName()),
// Placeholder.miniMessage("server", Bukkit.getServerName()), // Placeholder.miniMessage("[i]", itemComponent(player.getInventory().getItemInMainHand()))));
// Placeholder.miniMessage("[i]", itemComponent(player.getInventory().getItemInMainHand())))); //
// // Component component = Utility.parseMiniMessage(Config.PARTY_FORMAT, Placeholders);
// Component component = Utility.parseMiniMessage(Config.PARTY_FORMAT, Placeholders); //// sendPartyMessage(player, party.getPartyId(), component);
//// sendPartyMessage(player, party.getPartyId(), component); //
// // Component spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, Placeholders);
// Component spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, Placeholders); // for(Player pl : Bukkit.getOnlinePlayers()) {
// for(Player pl : Bukkit.getOnlinePlayers()) { // if(pl.hasPermission(Config.SPYPERMISSION) && !party.getPartyUsersUuid().contains(pl.getUniqueId())) {
// if(pl.hasPermission(Config.SPYPERMISSION) && !party.getPartyUsersUuid().contains(pl.getUniqueId())) { // pl.sendMessage(spyMessage);
// pl.sendMessage(spyMessage); // }
// } // }
// }
} }
private void sendChatChannelMessage(CustomChannel chatChannel, UUID uuid, Component component, String message) { private void sendChatChannelMessage(CustomChannel chatChannel, UUID uuid, ComponentLike component, String message) {
Player player = Bukkit.getPlayer(uuid); Player player = Bukkit.getPlayer(uuid);
if (player == null) { if (player == null) {
ALogger.warn("Failed to send chat message from non existent player"); ALogger.warn("Failed to send chat message from non existent player");
@ -254,9 +255,9 @@ public class ChatHandler {
if (!chatChannel.getServers().contains(ServerName.getServerName())) { if (!chatChannel.getServers().contains(ServerName.getServerName())) {
player.sendRichMessage("<red>Unable to send messages to <channel> in this server.</red>", player.sendRichMessage("<red>Unable to send messages to <channel> in this server.</red>",
Placeholder.parsed("channel", chatChannel.getChannelName())); Placeholder.parsed("channel", chatChannel.getChannelName()));
ALogger.info(String.format("Not sending chat message due to [%s] not being in this channels config", ALogger.info(String.format("Not sending chat message due to [%s] not being in this channels config",
ServerName.getServerName())); ServerName.getServerName()));
return; return;
} }
@ -264,16 +265,18 @@ public class ChatHandler {
.filter(p -> p.hasPermission(chatChannel.getPermission())); .filter(p -> p.hasPermission(chatChannel.getPermission()));
if (!player.hasPermission("chat.ignorebypass")) { if (!player.hasPermission("chat.ignorebypass")) {
stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid) stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid)
|| receiver.hasPermission("chat.ignorebypass")); || receiver.hasPermission("chat.ignorebypass"));
} }
if (chatChannel.isLocal()) { if (chatChannel.isLocal()) {
Location location = player.getLocation(); Location location = player.getLocation();
stream = stream.filter(receiver -> { stream = stream.filter(receiver -> {
Player receiverPlayer = Bukkit.getPlayer(receiver.getUniqueId()); Player receiverPlayer = Bukkit.getPlayer(receiver.getUniqueId());
if (receiverPlayer == null) if (receiverPlayer == null) {
return false; return false;
if (!location.getWorld().getUID().equals(receiverPlayer.getLocation().getWorld().getUID())) }
if (!location.getWorld().getUID().equals(receiverPlayer.getLocation().getWorld().getUID())) {
return false; return false;
}
return !(receiverPlayer.getLocation().distance(location) > Config.LOCAL_DISTANCE); return !(receiverPlayer.getLocation().distance(location) > Config.LOCAL_DISTANCE);
}); });
} }
@ -285,9 +288,9 @@ public class ChatHandler {
.filter(onlinePlayer -> onlinePlayer.hasPermission(Config.SPYPERMISSION)) .filter(onlinePlayer -> onlinePlayer.hasPermission(Config.SPYPERMISSION))
.filter(onlinePlayer -> !recipientUUIDs.contains(onlinePlayer.getUniqueId())) .filter(onlinePlayer -> !recipientUUIDs.contains(onlinePlayer.getUniqueId()))
.forEach(onlinePlayer -> onlinePlayer.sendRichMessage(Config.CHANNEL_SPY, .forEach(onlinePlayer -> onlinePlayer.sendRichMessage(Config.CHANNEL_SPY,
Placeholder.component("sender", player.name()), Placeholder.component("sender", player.name()),
Placeholder.parsed("channel", chatChannel.getChannelName()), Placeholder.parsed("channel", chatChannel.getChannelName()),
Placeholder.parsed("message", message))); Placeholder.parsed("message", message)));
} }
private void sendPluginMessage(Player player, String channel, Component component) { private void sendPluginMessage(Player player, String channel, Component component) {
@ -320,9 +323,11 @@ public class ChatHandler {
private boolean isMuted(Player player, String message, String prefix) { private boolean isMuted(Player player, String message, String prefix) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); 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 (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"))) { // 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)), ""); GalaxyUtility.sendBlockedNotification(prefix, player, Utility.parseMiniMessage(Utility.stripTokens(message)), "");
return true; return true;
} }
@ -331,11 +336,12 @@ public class ChatHandler {
public static Component itemComponent(ItemStack item) { public static Component itemComponent(ItemStack item) {
Component component = Component.text("[i]", NamedTextColor.AQUA); Component component = Component.text("[i]", NamedTextColor.AQUA);
if(item.getType().equals(Material.AIR)) if (item.getType().equals(Material.AIR)) {
return component.color(NamedTextColor.WHITE); return component.color(NamedTextColor.WHITE);
}
boolean dname = item.hasItemMeta() && item.getItemMeta().hasDisplayName(); boolean dname = item.hasItemMeta() && item.getItemMeta().hasDisplayName();
if(dname) { if (dname) {
component = component.append(item.getItemMeta().displayName()); component = component.append(Objects.requireNonNull(item.getItemMeta().displayName()));
} else { } else {
component = component.append(Component.text(materialToName(item.getType()), NamedTextColor.WHITE)); component = component.append(Component.text(materialToName(item.getType()), NamedTextColor.WHITE));
} }
@ -357,10 +363,12 @@ public class ChatHandler {
int loc = sb.lastIndexOf(split); int loc = sb.lastIndexOf(split);
char charLoc = sb.charAt(loc); char charLoc = sb.charAt(loc);
if (!(split.equalsIgnoreCase("of") || split.equalsIgnoreCase("and") || 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)); sb.setCharAt(loc, Character.toUpperCase(charLoc));
if (pos != splits.length - 1) }
if (pos != splits.length - 1) {
sb.append(' '); sb.append(' ');
}
++pos; ++pos;
} }
@ -379,7 +387,7 @@ public class ChatHandler {
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build(); MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(rawMessage); Component component = miniMessage.deserialize(rawMessage);
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) { for (ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText( component = component.replaceText(
TextReplacementConfig.builder() TextReplacementConfig.builder()
.times(Config.EMOTELIMIT) .times(Config.EMOTELIMIT)

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

@ -17,6 +17,7 @@ import io.papermc.paper.event.player.AsyncChatCommandDecorateEvent;
import io.papermc.paper.event.player.AsyncChatDecorateEvent; import io.papermc.paper.event.player.AsyncChatDecorateEvent;
import io.papermc.paper.event.player.AsyncChatEvent; import io.papermc.paper.event.player.AsyncChatEvent;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.TextReplacementConfig; import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.format.NamedTextColor; import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.MiniMessage;
@ -47,28 +48,32 @@ public class ChatListener implements Listener {
this.chatLogHandler = chatLogHandler; this.chatLogHandler = chatLogHandler;
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onChatCommandDecorate(AsyncChatCommandDecorateEvent event) { public void onChatCommandDecorate(AsyncChatCommandDecorateEvent event) {
if (event.player() == null) return; if (event.player() == null) {
return;
}
Component formatComponent = Component.text("%message%"); Component formatComponent = Component.text("%message%");
Component message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage())); ComponentLike message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build())); event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
} }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onChatDecorate(AsyncChatDecorateEvent event) { public void onChatDecorate(AsyncChatDecorateEvent event) {
if (event.player() == null) return; if (event.player() == null) {
return;
}
Component formatComponent = Component.text("%message%"); Component formatComponent = Component.text("%message%");
Component message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage())); ComponentLike message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build())); event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
} }
private final Component mention = MiniMessage.miniMessage().deserialize(Config.MENTIONPLAYERTAG); private final Component mention = MiniMessage.miniMessage().deserialize(Config.MENTIONPLAYERTAG);
@EventHandler(ignoreCancelled = true) @EventHandler(ignoreCancelled = true)
public void onPlayerChat(AsyncChatEvent event) { public void onPlayerChat(AsyncChatEvent event) {
event.setCancelled(true); //Always cancel the event because we do not want to deal with Microsoft's stupid bans event.setCancelled(true); //Always cancel the event because we do not want to deal with Microsoft's stupid bans
@ -86,12 +91,12 @@ public class ChatListener implements Listener {
Player player = event.getPlayer(); Player player = event.getPlayer();
UUID uuid = player.getUniqueId(); UUID uuid = player.getUniqueId();
Component input = event.message().colorIfAbsent(NamedTextColor.WHITE); ComponentLike input = event.message().colorIfAbsent(NamedTextColor.WHITE);
ModifiableString modifiableString = new ModifiableString(input); ModifiableString modifiableString = new ModifiableString(input.asComponent());
// todo a better way for this // todo a better way for this
if(!RegexManager.filterText(player.getName(), uuid, modifiableString, true, "chat", filterType -> { if (!RegexManager.filterText(player.getName(), uuid, modifiableString, true, "chat", filterType -> {
if (!filterType.equals(FilterType.PUNISH)) { if (!filterType.equals(FilterType.PUNISH)) {
ALogger.warn("Received another FilterType than punish when filtering chat and executing a filter action"); ALogger.warn("Received another FilterType than punish when filtering chat and executing a filter action");
return; return;
@ -105,9 +110,9 @@ public class ChatListener implements Listener {
})) { })) {
event.setCancelled(true); event.setCancelled(true);
GalaxyUtility.sendBlockedNotification("Language", player, GalaxyUtility.sendBlockedNotification("Language", player,
modifiableString.component(), modifiableString.component(),
""); "");
chatLogHandler.addChatLog(uuid, ServerName.getServerName(), PlainTextComponentSerializer.plainText().serialize(input), true); chatLogHandler.addChatLog(uuid, ServerName.getServerName(), PlainTextComponentSerializer.plainText().serialize(input.asComponent()), true);
return; // the message was blocked return; // the message was blocked
} }
@ -116,7 +121,7 @@ public class ChatListener implements Listener {
if (!player.hasPermission("chat.ignorebypass")) { if (!player.hasPermission("chat.ignorebypass")) {
stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid) stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid)
|| receiver.hasPermission("chat.ignorebypass")); || receiver.hasPermission("chat.ignorebypass"));
} }
Set<Player> receivers = stream.collect(Collectors.toSet()); Set<Player> receivers = stream.collect(Collectors.toSet());
@ -131,7 +136,7 @@ public class ChatListener implements Listener {
pingPlayer.playSound(pingPlayer.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1); pingPlayer.playSound(pingPlayer.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1);
} }
chatLogHandler.addChatLog(uuid, ServerName.getServerName(), modifiableString.string(), false); chatLogHandler.addChatLog(uuid, ServerName.getServerName(), modifiableString.string(), false);
ALogger.info(PlainTextComponentSerializer.plainText().serialize(input)); ALogger.info(PlainTextComponentSerializer.plainText().serialize(input.asComponent()));
} }
private void pingPlayers(Set<Player> playersToPing, ModifiableString modifiableString, Player player) { private void pingPlayers(Set<Player> playersToPing, ModifiableString modifiableString, Player player) {
@ -147,10 +152,10 @@ public class ChatListener implements Listener {
ChatUser onlinePlayerUser = ChatUserManager.getChatUser(onlinePlayer.getUniqueId()); ChatUser onlinePlayerUser = ChatUserManager.getChatUser(onlinePlayer.getUniqueId());
if (namePattern.matcher(modifiableString.string()).find()) { if (namePattern.matcher(modifiableString.string()).find()) {
modifiableString.replace(TextReplacementConfig.builder() modifiableString.replace(TextReplacementConfig.builder()
.once() .once()
.match(namePattern) .match(namePattern)
.replacement(mention.append(onlinePlayerUser.getDisplayName())) .replacement(mention.append(onlinePlayerUser.getDisplayName()))
.build()); .build());
//TODO replace all instances of \name with just name but using the match result so the capitalization doesn't change //TODO replace all instances of \name with just name but using the match result so the capitalization doesn't change
// modifiableString.replace(TextReplacementConfig.builder() // modifiableString.replace(TextReplacementConfig.builder()
// .once() // .once()
@ -161,24 +166,24 @@ public class ChatListener implements Listener {
// }); // });
if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId()) if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
|| player.hasPermission("chat.ignorebypass")) { || player.hasPermission("chat.ignorebypass")) {
playersToPing.add(onlinePlayer); playersToPing.add(onlinePlayer);
} }
} else if (nickPattern.matcher(modifiableString.string()).find()) { } else if (nickPattern.matcher(modifiableString.string()).find()) {
modifiableString.replace(TextReplacementConfig.builder() modifiableString.replace(TextReplacementConfig.builder()
.once() .once()
.match(nickPattern) .match(nickPattern)
.replacement(mention.append(onlinePlayerUser.getDisplayName())) .replacement(mention.append(onlinePlayerUser.getDisplayName()))
.build()); .build());
if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId()) if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
|| player.hasPermission("chat.ignorebypass")) { || player.hasPermission("chat.ignorebypass")) {
playersToPing.add(onlinePlayer); playersToPing.add(onlinePlayer);
} }
} }
} }
} }
public @NotNull Component render(@NotNull Player player, @NotNull Component message) { public @NotNull ComponentLike render(@NotNull Player player, @NotNull Component message) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", user.getDisplayName()), Placeholder.component("sender", user.getDisplayName()),
@ -187,12 +192,12 @@ public class ChatListener implements Listener {
Placeholder.component("prefixall", user.getPrefixAll()), Placeholder.component("prefixall", user.getPrefixAll()),
Placeholder.component("staffprefix", user.getStaffPrefix()), Placeholder.component("staffprefix", user.getStaffPrefix()),
Placeholder.component("message", message) Placeholder.component("message", message)
); );
return Utility.parseMiniMessage(Config.CHATFORMAT, placeholders); return Utility.parseMiniMessage(Config.CHATFORMAT, placeholders);
} }
private Component parseMessageContent(Player player, String rawMessage) { private ComponentLike parseMessageContent(Player player, String rawMessage) {
TagResolver.Builder tagResolver = TagResolver.builder(); TagResolver.Builder tagResolver = TagResolver.builder();
Utility.formattingPerms.forEach((perm, pair) -> { Utility.formattingPerms.forEach((perm, pair) -> {
@ -203,7 +208,7 @@ public class ChatListener implements Listener {
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build(); MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(Utility.formatText(rawMessage)); Component component = miniMessage.deserialize(Utility.formatText(rawMessage));
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) { for (ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText( component = component.replaceText(
TextReplacementConfig.builder() TextReplacementConfig.builder()
.times(Config.EMOTELIMIT) .times(Config.EMOTELIMIT)
@ -213,11 +218,11 @@ public class ChatListener implements Listener {
component = component component = component
.replaceText( .replaceText(
TextReplacementConfig.builder() TextReplacementConfig.builder()
.once() .once()
.matchLiteral("[i]") .matchLiteral("[i]")
.replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand())) .replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand()))
.build()); .build());
return component; return component;

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

@ -5,17 +5,18 @@ import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries; import com.alttd.chat.database.Queries;
import com.alttd.chat.managers.ChatUserManager; import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.PartyManager; import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Party; import com.alttd.chat.objects.Party;
import com.alttd.chat.objects.PartyUser; import com.alttd.chat.objects.PartyUser;
import com.alttd.chat.objects.channels.Channel; import com.alttd.chat.objects.channels.Channel;
import com.alttd.chat.objects.channels.CustomChannel; import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.util.ALogger; import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.ServerName; import com.alttd.chat.util.ServerName;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataInput; import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteStreams; import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer; import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.Sound; import org.bukkit.Sound;
@ -50,8 +51,9 @@ public class PluginMessage implements PluginMessageListener {
player.sendMessage(GsonComponentSerializer.gson().deserialize(message)); player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
player.playSound(player.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1); // todo load this from config player.playSound(player.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1); // todo load this from config
ChatUser user = ChatUserManager.getChatUser(uuid); ChatUser user = ChatUserManager.getChatUser(uuid);
if (!user.getReplyContinueTarget().equalsIgnoreCase(target)) if (!user.getReplyContinueTarget().equalsIgnoreCase(target)) {
user.setReplyTarget(target); user.setReplyTarget(target);
}
} }
} }
case "privatemessageout": { case "privatemessageout": {
@ -67,13 +69,15 @@ public class PluginMessage implements PluginMessageListener {
if (isTargetNotIgnored(chatUser, targetuuid)) { if (isTargetNotIgnored(chatUser, targetuuid)) {
chatUser.setReplyTarget(target); chatUser.setReplyTarget(target);
player.sendMessage(GsonComponentSerializer.gson().deserialize(message)); player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
// ChatUser user = ChatUserManager.getChatUser(uuid); // ChatUser user = ChatUserManager.getChatUser(uuid);
// user.setReplyTarget(target); // user.setReplyTarget(target);
} }
break; break;
} }
case "globalchat": { case "globalchat": {
if (!ChatPlugin.getInstance().serverGlobalChatEnabled() || ChatPlugin.getInstance().serverMuted()) break; if (!ChatPlugin.getInstance().serverGlobalChatEnabled() || ChatPlugin.getInstance().serverMuted()) {
break;
}
UUID uuid = UUID.fromString(in.readUTF()); UUID uuid = UUID.fromString(in.readUTF());
String message = in.readUTF(); String message = in.readUTF();
@ -90,7 +94,7 @@ public class PluginMessage implements PluginMessageListener {
ChatUser chatUser = ChatUserManager.getChatUser(UUID.fromString(in.readUTF())); ChatUser chatUser = ChatUserManager.getChatUser(UUID.fromString(in.readUTF()));
UUID targetUUID = UUID.fromString(in.readUTF()); UUID targetUUID = UUID.fromString(in.readUTF());
if(!chatUser.getIgnoredPlayers().contains(targetUUID)) { if (!chatUser.getIgnoredPlayers().contains(targetUUID)) {
chatUser.addIgnoredPlayers(targetUUID); chatUser.addIgnoredPlayers(targetUUID);
} }
break; break;
@ -101,12 +105,14 @@ public class PluginMessage implements PluginMessageListener {
break; break;
} }
case "chatchannel": { case "chatchannel": {
if (ChatPlugin.getInstance().serverMuted()) break; if (ChatPlugin.getInstance().serverMuted()) {
break;
}
chatChannel(in); chatChannel(in);
break; break;
} }
case "tmppartyupdate" : { case "tmppartyupdate": {
int id = Integer.parseInt(in.readUTF()); int id = Integer.parseInt(in.readUTF());
new BukkitRunnable() { new BukkitRunnable() {
@Override @Override
@ -128,8 +134,8 @@ public class PluginMessage implements PluginMessageListener {
@Override @Override
public void run() { public void run() {
PartyUser user = party.getPartyUser(uuid); PartyUser user = party.getPartyUser(uuid);
if(user != null) { if (user != null) {
Component component = Utility.parseMiniMessage("<dark_aqua>* " + user.getPlayerName() + " logged in to Altitude."); ComponentLike component = Utility.parseMiniMessage("<dark_aqua>* " + user.getPlayerName() + " logged in to Altitude.");
Bukkit.getOnlinePlayers().stream() Bukkit.getOnlinePlayers().stream()
.filter(p -> party.getPartyUsersUuid().contains(p.getUniqueId())) .filter(p -> party.getPartyUsersUuid().contains(p.getUniqueId()))
@ -152,8 +158,8 @@ public class PluginMessage implements PluginMessageListener {
@Override @Override
public void run() { public void run() {
PartyUser user = party.getPartyUser(uuid); PartyUser user = party.getPartyUser(uuid);
if(user != null) { if (user != null) {
Component component = Utility.parseMiniMessage("<dark_aqua>* " + user.getPlayerName() + " logged out of Altitude."); ComponentLike component = Utility.parseMiniMessage("<dark_aqua>* " + user.getPlayerName() + " logged out of Altitude.");
Bukkit.getOnlinePlayers().stream() Bukkit.getOnlinePlayers().stream()
.filter(p -> party.getPartyUsersUuid().contains(p.getUniqueId())) .filter(p -> party.getPartyUsersUuid().contains(p.getUniqueId()))
@ -171,7 +177,9 @@ public class PluginMessage implements PluginMessageListener {
UUID uuid = UUID.fromString(in.readUTF()); UUID uuid = UUID.fromString(in.readUTF());
boolean mute = in.readBoolean(); boolean mute = in.readBoolean();
ChatUser user = ChatUserManager.getChatUser(uuid); ChatUser user = ChatUserManager.getChatUser(uuid);
if (user == null) return; if (user == null) {
return;
}
user.setMuted(mute); user.setMuted(mute);
break; break;
default: default:
@ -187,8 +195,8 @@ public class PluginMessage implements PluginMessageListener {
chatChannel = (CustomChannel) Channel.getChatChannel(in.readUTF()); chatChannel = (CustomChannel) Channel.getChatChannel(in.readUTF());
uuid = UUID.fromString(in.readUTF()); uuid = UUID.fromString(in.readUTF());
component = GsonComponentSerializer.gson().deserialize(in.readUTF()); component = GsonComponentSerializer.gson().deserialize(in.readUTF());
} catch (Exception e) { //Idk the exception for reading too far into in.readUTF() } catch (Exception e) {
e.printStackTrace(); ALogger.error("Failed to read ChatChannel message.", e);
} }
if (chatChannel == null) { if (chatChannel == null) {

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

@ -4,100 +4,21 @@ import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config; import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries; import com.alttd.chat.database.Queries;
import com.alttd.chat.objects.Nick; import com.alttd.chat.objects.Nick;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataOutput; import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams; 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.OfflinePlayer;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import java.awt.*;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream; import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList;
import java.util.UUID; import java.util.UUID;
public class NickUtilities public class NickUtilities {
{
public static String stringRegen; 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) { public static String removeAllColors(String string) {
for (final String colorCodes : Config.NICK_ALLOWED_COLOR_CODESLIST) { for (final String colorCodes : Config.NICK_ALLOWED_COLOR_CODESLIST) {
@ -111,34 +32,11 @@ public class NickUtilities
NickUtilities.stringRegen = "\\{#[A-Fa-f0-9]{6}(<)?(>)?}"; 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() { public static void updateCache() {
if (!Nicknames.getInstance().nickCacheUpdate.isEmpty()){ if (!Nicknames.getInstance().nickCacheUpdate.isEmpty()) {
Nicknames.getInstance().nickCacheUpdate.forEach(uuid ->{ Nicknames.getInstance().nickCacheUpdate.forEach(uuid -> {
Nick nick = Queries.getNick(uuid); Nick nick = Queries.getNick(uuid);
if (nick == null){ if (nick == null) {
Nicknames.getInstance().NickCache.remove(uuid); Nicknames.getInstance().NickCache.remove(uuid);
} else { } else {
Nicknames.getInstance().NickCache.put(uuid, nick); Nicknames.getInstance().NickCache.put(uuid, nick);
@ -174,13 +72,13 @@ public class NickUtilities
return true; return true;
} }
for (Nick nick : Nicknames.getInstance().NickCache.values()){ for (Nick nick : Nicknames.getInstance().NickCache.values()) {
if (!nick.getUuid().equals(target.getUniqueId()) if (!nick.getUuid().equals(target.getUniqueId())
&& ((nick.getCurrentNickNoColor() != null && nick.getCurrentNickNoColor().equalsIgnoreCase(cleanNick)) && ((nick.getCurrentNickNoColor() != null && nick.getCurrentNickNoColor().equalsIgnoreCase(cleanNick))
|| (nick.getNewNickNoColor() != null && nick.getNewNickNoColor().equalsIgnoreCase(cleanNick)))){ || (nick.getNewNickNoColor() != null && nick.getNewNickNoColor().equalsIgnoreCase(cleanNick)))) {
UUID uuid = nick.getUuid(); UUID uuid = nick.getUuid();
UUID uniqueId = target.getUniqueId(); UUID uniqueId = target.getUniqueId();
if (uniqueId.equals(uuid)){ if (uniqueId.equals(uuid)) {
ChatPlugin.getInstance().getLogger().info(uuid + " " + uniqueId); ChatPlugin.getInstance().getLogger().info(uuid + " " + uniqueId);
} }
sender.sendRichMessage(Config.NICK_TAKEN); sender.sendRichMessage(Config.NICK_TAKEN);
@ -204,16 +102,16 @@ public class NickUtilities
public static void bungeeMessageHandled(UUID uniqueId, Player player, String channel) { public static void bungeeMessageHandled(UUID uniqueId, Player player, String channel) {
ByteArrayDataOutput out = ByteStreams.newDataOutput(); ByteArrayDataOutput out = ByteStreams.newDataOutput();
// out.writeUTF("Forward"); // So BungeeCord knows to forward it // out.writeUTF("Forward"); // So BungeeCord knows to forward it
// out.writeUTF("ALL"); // out.writeUTF("ALL");
out.writeUTF("NickName" + channel); // The channel name to check if this your data out.writeUTF("NickName" + channel); // The channel name to check if this your data
ByteArrayOutputStream msgbytes = new ByteArrayOutputStream(); ByteArrayOutputStream msgbytes = new ByteArrayOutputStream();
DataOutputStream msgout = new DataOutputStream(msgbytes); DataOutputStream msgout = new DataOutputStream(msgbytes);
try { try {
msgout.writeUTF(uniqueId.toString()); msgout.writeUTF(uniqueId.toString());
} catch (IOException exception){ } catch (IOException exception) {
exception.printStackTrace(); ALogger.error("Failed to write UUID to byte array", exception);
return; return;
} }
byte[] bytes = msgbytes.toByteArray(); byte[] bytes = msgbytes.toByteArray();

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

@ -8,6 +8,7 @@ import com.alttd.chat.events.NickEvent;
import com.alttd.chat.managers.ChatUserManager; import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.objects.ChatUser; import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Nick; import com.alttd.chat.objects.Nick;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataOutput; import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams; import com.google.common.io.ByteStreams;
@ -21,7 +22,6 @@ import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter; import org.bukkit.command.TabCompleter;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
@ -47,7 +47,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String label, String[] args) { public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String label, String[] args) {
if (sender instanceof Player player) { if (sender instanceof Player player) {
if (args.length == 0) { if (args.length == 0) {
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL))); sender.sendRichMessage(helpMessage(sender, HelpType.ALL));
return true; return true;
} }
switch (args[0].toLowerCase()) { switch (args[0].toLowerCase()) {
@ -60,10 +60,10 @@ public class Nicknames implements CommandExecutor, TabCompleter {
if (offlinePlayer.isOnline() || offlinePlayer.hasPlayedBefore()) { if (offlinePlayer.isOnline() || offlinePlayer.hasPlayedBefore()) {
handleNick(player, offlinePlayer, args[2]); handleNick(player, offlinePlayer, args[2]);
} else { } else {
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.SET_OTHERS))); sender.sendRichMessage(helpMessage(sender, HelpType.SET_OTHERS));
} }
} else if (args.length > 3) { } else if (args.length > 3) {
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.SET_SELF, HelpType.SET_OTHERS))); sender.sendRichMessage(helpMessage(sender, HelpType.SET_SELF, HelpType.SET_OTHERS));
} }
break; break;
case "review": case "review":
@ -72,7 +72,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
ChatPlugin.getInstance().getServer().getPluginManager().registerEvents(nicknamesGui, ChatPlugin.getInstance()); ChatPlugin.getInstance().getServer().getPluginManager().registerEvents(nicknamesGui, ChatPlugin.getInstance());
nicknamesGui.openInventory(player); nicknamesGui.openInventory(player);
} else { } else {
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.REVIEW))); sender.sendRichMessage(helpMessage(sender, HelpType.REVIEW));
} }
break; break;
case "request": case "request":
@ -84,7 +84,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
} }
}.runTaskAsynchronously(ChatPlugin.getInstance()); }.runTaskAsynchronously(ChatPlugin.getInstance());
} else { } else {
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.REQUEST))); sender.sendRichMessage(helpMessage(sender, HelpType.REQUEST));
} }
break; break;
case "try": case "try":
@ -92,17 +92,17 @@ public class Nicknames implements CommandExecutor, TabCompleter {
LuckPerms api = ChatAPI.get().getLuckPerms(); LuckPerms api = ChatAPI.get().getLuckPerms();
if (api != null) { if (api != null) {
if (NickUtilities.validNick(player, player, args[1])) { if (NickUtilities.validNick(player, player, args[1])) {
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_TRYOUT, sender.sendRichMessage(Config.NICK_TRYOUT,
Placeholder.component("prefix", Utility.applyColor(api.getUserManager().getUser(player.getUniqueId()) Placeholder.component("prefix", Utility.applyColor(api.getUserManager().getUser(player.getUniqueId())
.getCachedData().getMetaData().getPrefix())), // TODO pull this from chatuser? .getCachedData().getMetaData().getPrefix())), // TODO pull this from chatuser?
Placeholder.component("nick", Utility.applyColor(args[1])), Placeholder.component("nick", Utility.applyColor(args[1])),
Placeholder.unparsed("nickrequest", args[1]))); Placeholder.unparsed("nickrequest", args[1]));
} }
} else { } else {
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_NO_LUCKPERMS)); sender.sendRichMessage(Config.NICK_NO_LUCKPERMS);
} }
} else { } else {
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.TRY))); sender.sendRichMessage(helpMessage(sender, HelpType.TRY));
} }
break; break;
case "current": case "current":
@ -111,16 +111,16 @@ public class Nicknames implements CommandExecutor, TabCompleter {
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.component("nickname", chatUser.getDisplayName()), Placeholder.component("nickname", chatUser.getDisplayName()),
Placeholder.parsed("currentnickname", chatUser.getNickNameString()) Placeholder.parsed("currentnickname", chatUser.getNickNameString())
); );
player.sendRichMessage(Config.NICK_CURRENT, placeholders); player.sendRichMessage(Config.NICK_CURRENT, placeholders);
} }
break; break;
case "help": case "help":
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL) 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>")); + "For more info on nicknames and how to use rgb colors go to: <aqua>https://alttd.com/nicknames<white>");
break; break;
default: default:
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL))); sender.sendRichMessage(helpMessage(sender, HelpType.ALL));
} }
} else { } else {
sender.sendMessage("Console commands are disabled."); sender.sendMessage("Console commands are disabled.");
@ -131,7 +131,9 @@ public class Nicknames implements CommandExecutor, TabCompleter {
@Override @Override
public List<String> onTabComplete(CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) { public List<String> onTabComplete(CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
List<String> completions = new ArrayList<>(); 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) { if (args.length == 1) {
List<String> choices = new ArrayList<>(); List<String> choices = new ArrayList<>();
@ -191,15 +193,15 @@ public class Nicknames implements CommandExecutor, TabCompleter {
long waitTime = Config.NICK_WAIT_TIME; long waitTime = Config.NICK_WAIT_TIME;
if (timeSinceLastChange > waitTime || player.hasPermission("chat.command.nick.bypasswaittime")) { if (timeSinceLastChange > waitTime || player.hasPermission("chat.command.nick.bypasswaittime")) {
if (nick.hasRequest()) { if (nick.hasRequest()) {
player.sendMessage(Utility.parseMiniMessage(Config.NICK_REQUEST_PLACED, player.sendRichMessage(Config.NICK_REQUEST_PLACED,
Placeholder.component("oldrequestednick", Utility.applyColor(nick.getNewNick())), Placeholder.component("oldrequestednick", Utility.applyColor(nick.getNewNick())),
Placeholder.component("newrequestednick", Utility.applyColor(nickName)))); Placeholder.component("newrequestednick", Utility.applyColor(nickName)));
} }
nick.setNewNick(nickName); nick.setNewNick(nickName);
nick.setRequestedDate(new Date().getTime()); nick.setRequestedDate(new Date().getTime());
} else { } else {
player.sendMessage(Utility.parseMiniMessage(Config.NICK_TOO_SOON, player.sendRichMessage(Config.NICK_TOO_SOON,
Placeholder.unparsed("time", formatTime((timeSinceLastChange-waitTime)*-1)))); Placeholder.unparsed("time", formatTime((timeSinceLastChange - waitTime) * -1)));
return; return;
} }
} else { } else {
@ -207,8 +209,8 @@ public class Nicknames implements CommandExecutor, TabCompleter {
} }
Queries.newNicknameRequest(uniqueId, nickName); Queries.newNicknameRequest(uniqueId, nickName);
bungeeMessageRequest(player); bungeeMessageRequest(player);
player.sendMessage(Utility.parseMiniMessage(Config.NICK_REQUESTED, player.sendRichMessage(Config.NICK_REQUESTED,
Placeholder.component("nick", Utility.applyColor(nickName)))); Placeholder.component("nick", Utility.applyColor(nickName)));
} }
private void bungeeMessageRequest(Player player) { private void bungeeMessageRequest(Player player) {
@ -216,8 +218,8 @@ public class Nicknames implements CommandExecutor, TabCompleter {
UUID uniqueId = player.getUniqueId(); UUID uniqueId = player.getUniqueId();
// out.writeUTF("Forward"); // So BungeeCord knows to forward it // out.writeUTF("Forward"); // So BungeeCord knows to forward it
// out.writeUTF("ALL"); // out.writeUTF("ALL");
out.writeUTF("NickNameRequest"); // The channel name to check if this your data out.writeUTF("NickNameRequest"); // The channel name to check if this your data
ByteArrayOutputStream msgbytes = new ByteArrayOutputStream(); ByteArrayOutputStream msgbytes = new ByteArrayOutputStream();
@ -225,7 +227,7 @@ public class Nicknames implements CommandExecutor, TabCompleter {
try { try {
msgout.writeUTF(uniqueId.toString()); msgout.writeUTF(uniqueId.toString());
} catch (IOException exception) { } catch (IOException exception) {
exception.printStackTrace(); ALogger.error("Failed to write UUID to ByteArrayOutputStream", exception);
return; return;
} }
byte[] bytes = msgbytes.toByteArray(); byte[] bytes = msgbytes.toByteArray();
@ -244,13 +246,13 @@ public class Nicknames implements CommandExecutor, TabCompleter {
long days = (timeInMillis / (1000 * 60 * 60 * 24)); long days = (timeInMillis / (1000 * 60 * 60 * 24));
StringBuilder stringBuilder = new StringBuilder(); StringBuilder stringBuilder = new StringBuilder();
if (days!=0) { if (days != 0) {
stringBuilder.append(days).append(" days "); stringBuilder.append(days).append(" days ");
} }
if (days!=0 || hour!=0) { if (days != 0 || hour != 0) {
stringBuilder.append(hour).append(" hours "); stringBuilder.append(hour).append(" hours ");
} }
if (days!=0 || hour!=0 || minute != 0) { if (days != 0 || hour != 0 || minute != 0) {
stringBuilder.append(minute).append(" minutes and "); stringBuilder.append(minute).append(" minutes and ");
} }
stringBuilder.append(second).append(" seconds"); stringBuilder.append(second).append(" seconds");
@ -262,22 +264,22 @@ public class Nicknames implements CommandExecutor, TabCompleter {
try { try {
if (target.isOnline()) { if (target.isOnline()) {
resetNick(target.getPlayer()); resetNick(Objects.requireNonNull(target.getPlayer()));
} }
Queries.removePlayerFromDataBase(target.getUniqueId()); Queries.removePlayerFromDataBase(target.getUniqueId());
NickCache.remove(target.getUniqueId()); NickCache.remove(target.getUniqueId());
nickCacheUpdate.add(target.getUniqueId()); nickCacheUpdate.add(target.getUniqueId());
} catch (SQLException e) { } catch (SQLException e) {
e.printStackTrace(); ALogger.error("Failed to remove nickname from database", e);
} }
if (!sender.equals(target)) { if (!sender.equals(target)) {
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_RESET_OTHERS, sender.sendRichMessage(Config.NICK_RESET_OTHERS,
Placeholder.unparsed("player", target.getName()))); Placeholder.unparsed("player", Objects.requireNonNull(target.getName())));
} }
if (target.isOnline() && target.getPlayer() != null) { if (target.isOnline() && target.getPlayer() != null) {
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_RESET)); target.getPlayer().sendRichMessage(Config.NICK_RESET);
} }
NickEvent nickEvent = new NickEvent(sender.getName(), target.getName(), null, NickEvent.NickEventType.RESET); NickEvent nickEvent = new NickEvent(sender.getName(), target.getName(), null, NickEvent.NickEventType.RESET);
@ -305,17 +307,19 @@ public class Nicknames implements CommandExecutor, TabCompleter {
if (!sender.equals(target)) { if (!sender.equals(target)) {
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_CHANGED_OTHERS, sender.sendMessage(Utility.parseMiniMessage(Config.NICK_CHANGED_OTHERS,
Placeholder.unparsed("targetplayer", target.getName()), Placeholder.unparsed("targetplayer", Objects.requireNonNull(target.getName())),
Placeholder.unparsed("nickname", nickName))); Placeholder.unparsed("nickname", nickName)));
if (target.isOnline()) { if (target.isOnline()) {
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_TARGET_NICK_CHANGE, Objects.requireNonNull(target.getPlayer())
Placeholder.unparsed("nickname", getNick(target.getPlayer())), .sendRichMessage(Config.NICK_TARGET_NICK_CHANGE,
Placeholder.unparsed("sendernick", getNick(sender)), Placeholder.unparsed("nickname", getNick(target.getPlayer())),
Placeholder.unparsed("player", target.getName()))); Placeholder.unparsed("sendernick", getNick(sender)),
Placeholder.unparsed("player", target.getName()));
} }
} else if (target.isOnline()) { } else if (target.isOnline()) {
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_CHANGED, Objects.requireNonNull(target.getPlayer())
Placeholder.unparsed("nickname", getNick(target.getPlayer())))); .sendRichMessage(Config.NICK_CHANGED,
Placeholder.unparsed("nickname", getNick(target.getPlayer())));
} }
} }
} }
@ -353,8 +357,10 @@ public class Nicknames implements CommandExecutor, TabCompleter {
break; break;
case REQUEST: case REQUEST:
if (sender.hasPermission("chat.command.nick.request")) { if (sender.hasPermission("chat.command.nick.request")) {
message.append("<gold>/nick request <nickname><white> - Requests a username to be reviewed by staff.\n" + message.append("""
" <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"); <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!
""");
} }
break; break;
case REVIEW: case REVIEW:
@ -381,8 +387,8 @@ public class Nicknames implements CommandExecutor, TabCompleter {
public void resetNick(final Player player) { public void resetNick(final Player player) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
user.setDisplayName(player.getName()); user.setDisplayName(player.getName());
player.displayName(user.getDisplayName()); player.displayName(user.getDisplayName().asComponent());
// updateCMIUser(player, null); // updateCMIUser(player, null);
} }
public String getNick(final Player player) { public String getNick(final Player player) {
@ -391,42 +397,13 @@ public class Nicknames implements CommandExecutor, TabCompleter {
} }
public void setNick(final Player player, final String nickName) { public void setNick(final Player player, final String nickName) {
if (player == null) if (player == null) {
return; return;
}
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId()); ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
user.setDisplayName(nickName); user.setDisplayName(nickName);
player.displayName(user.getDisplayName()); player.displayName(user.getDisplayName().asComponent());
// 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() { public static Nicknames getInstance() {

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

@ -5,9 +5,11 @@ import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries; import com.alttd.chat.database.Queries;
import com.alttd.chat.objects.Nick; import com.alttd.chat.objects.Nick;
import com.alttd.chat.util.ALogger; import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.Utility;
import com.google.common.io.ByteArrayDataInput; import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteStreams; import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.Component; 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.ClickEvent;
import net.kyori.adventure.text.event.HoverEvent; import net.kyori.adventure.text.event.HoverEvent;
import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.MiniMessage;
@ -29,7 +31,6 @@ import java.util.UUID;
public class NicknamesEvents implements Listener, PluginMessageListener { public class NicknamesEvents implements Listener, PluginMessageListener {
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onPlayerJoin(PlayerJoinEvent e) { public void onPlayerJoin(PlayerJoinEvent e) {
@ -54,9 +55,9 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
strippedNick = MiniMessage.miniMessage().stripTags(Nicknames.getInstance().getNick(player)); strippedNick = MiniMessage.miniMessage().stripTags(Nicknames.getInstance().getNick(player));
} catch (NullPointerException ignored) { } catch (NullPointerException ignored) {
} }
// final String strippedNick = CMIChatColor.stripColor(Nicknames.getInstance().getNick(player)); // final String strippedNick = CMIChatColor.stripColor(Nicknames.getInstance().getNick(player));
// final String cmiNick = Util.CMIChatColor.deColorize(Nicknames.getInstance().getNick(player)); // final String cmiNick = Util.CMIChatColor.deColorize(Nicknames.getInstance().getNick(player));
if (nickName == null) { if (nickName == null) {
Nicknames.getInstance().resetNick(player); Nicknames.getInstance().resetNick(player);
@ -75,8 +76,8 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
} }
if (i > 0) { if (i > 0) {
player.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_REQUESTS_ON_LOGIN, player.sendRichMessage(Config.NICK_REQUESTS_ON_LOGIN,
Placeholder.unparsed("amount", String.valueOf(i)))); Placeholder.unparsed("amount", String.valueOf(i)));
} }
} }
} }
@ -93,7 +94,7 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
String subChannel = in.readUTF(); String subChannel = in.readUTF();
ALogger.info(channel + ": " + subChannel); ALogger.info(channel + ": " + subChannel);
if (!subChannel.equals("NickNameRequest") && !subChannel.equals("NickNameAccepted") if (!subChannel.equals("NickNameRequest") && !subChannel.equals("NickNameAccepted")
&& !subChannel.equals("NickNameDenied") && !subChannel.equals("NickNameSet")) { && !subChannel.equals("NickNameDenied") && !subChannel.equals("NickNameSet")) {
return; return;
} }
UUID playerUUID; UUID playerUUID;
@ -110,18 +111,18 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
name = offlinePlayer.getName() == null ? playerUUID.toString() : offlinePlayer.getName(); name = offlinePlayer.getName() == null ? playerUUID.toString() : offlinePlayer.getName();
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); ALogger.error("Failed to read plugin message", e);
return; return;
} }
MiniMessage miniMessage = MiniMessage.miniMessage(); MiniMessage miniMessage = MiniMessage.miniMessage();
switch (subChannel) { switch (subChannel) {
case "NickNameRequest": case "NickNameRequest":
Component component = miniMessage.deserialize(Config.NICK_REQUEST_NEW, Placeholder.parsed("player", name)) ComponentLike component = miniMessage.deserialize(Config.NICK_REQUEST_NEW, Placeholder.parsed("player", name))
.clickEvent(ClickEvent.clickEvent(ClickEvent.Action.RUN_COMMAND, .clickEvent(ClickEvent.clickEvent(ClickEvent.Action.RUN_COMMAND,
"/nick review")) "/nick review"))
.hoverEvent(HoverEvent.hoverEvent(HoverEvent.Action.SHOW_TEXT, .hoverEvent(HoverEvent.hoverEvent(HoverEvent.Action.SHOW_TEXT,
miniMessage.deserialize("<gold>Click this text to review the request!"))); miniMessage.deserialize("<gold>Click this text to review the request!")));
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> { ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("chat.command.nick.review")) { if (p.hasPermission("chat.command.nick.review")) {
@ -138,8 +139,9 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
} }
break; break;
case "NickNameAccepted": case "NickNameAccepted":
Component deserialize = miniMessage.deserialize("<green><name>'s nickname was accepted!",
Placeholder.unparsed("name", name)); ComponentLike deserialize = Utility.parseMiniMessage("<green><name>'s nickname was accepted!",
Placeholder.unparsed("name", name));
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> { ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("chat.command.nick.review")) { if (p.hasPermission("chat.command.nick.review")) {
p.sendMessage(deserialize); p.sendMessage(deserialize);
@ -153,14 +155,14 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
Player target = Bukkit.getPlayer(playerUUID); Player target = Bukkit.getPlayer(playerUUID);
if (target != null && nick != null && nick.getCurrentNick() != null) { if (target != null && nick != null && nick.getCurrentNick() != null) {
Nicknames.getInstance().setNick(target, nick.getCurrentNick()); Nicknames.getInstance().setNick(target, nick.getCurrentNick());
target.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_CHANGED, target.sendRichMessage(Config.NICK_CHANGED,
Placeholder.unparsed("nickname", nick.getCurrentNick()))); Placeholder.unparsed("nickname", nick.getCurrentNick()));
} }
} }
break; break;
case "NickNameDenied": case "NickNameDenied":
final Component messageDenied = miniMessage.deserialize("<red><name>'s nickname was denied", final Component messageDenied = miniMessage.deserialize("<red><name>'s nickname was denied",
Placeholder.unparsed("name", name)); Placeholder.unparsed("name", name));
Nick nick = Nicknames.getInstance().NickCache.get(playerUUID); Nick nick = Nicknames.getInstance().NickCache.get(playerUUID);
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> { ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
@ -181,9 +183,11 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
if (offlinePlayer.isOnline()) { if (offlinePlayer.isOnline()) {
Player target = Bukkit.getPlayer(playerUUID); Player target = Bukkit.getPlayer(playerUUID);
if (target == null) break; if (target == null) {
target.sendMessage(MiniMessage.miniMessage().deserialize(Config.NICK_NOT_CHANGED, break;
Placeholder.unparsed("nickname", nick.getCurrentNick()))); }
target.sendRichMessage(Config.NICK_NOT_CHANGED,
Placeholder.unparsed("nickname", nick.getCurrentNick()));
} }
break; break;
} }

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

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

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

@ -2,12 +2,9 @@ package com.alttd.chat.util;
import com.alttd.chat.config.Config; import com.alttd.chat.config.Config;
import com.alttd.chat.managers.RegexManager; import com.alttd.chat.managers.RegexManager;
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.tag.resolver.Placeholder; 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.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.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
@ -16,40 +13,22 @@ import java.util.List;
public class GalaxyUtility { public class GalaxyUtility {
public static void sendBlockedNotification(String prefix, Player player, String input, String target) { public static void sendBlockedNotification(String prefix, Player player, ComponentLike 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.parsed("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 sendBlockedNotification(String prefix, Player player, Component input, String target) {
TagResolver placeholders = TagResolver.resolver( TagResolver placeholders = TagResolver.resolver(
Placeholder.parsed("prefix", prefix), Placeholder.parsed("prefix", prefix),
Placeholder.parsed("displayname", Utility.getDisplayName(player.getUniqueId(), player.getName())), Placeholder.parsed("displayname", Utility.getDisplayName(player.getUniqueId(), player.getName())),
Placeholder.parsed("target", (target.isEmpty() ? "tried to say:" : "-> " + target + ":")), Placeholder.parsed("target", (target.isEmpty() ? "tried to say:" : "-> " + target + ":")),
Placeholder.component("input", input) Placeholder.component("input", input)
); );
Component blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, placeholders); ComponentLike blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, placeholders);
Bukkit.getOnlinePlayers().forEach(a ->{ Bukkit.getOnlinePlayers().forEach(a -> {
if (a.hasPermission("chat.alert-blocked")) { if (a.hasPermission("chat.alert-blocked")) {
a.sendMessage(blockedNotification); a.sendMessage(blockedNotification);
} }
}); });
player.sendMessage(Utility.parseMiniMessage("<red>The language you used in your message is not allowed, " + 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>")); "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) { public static void addAdditionalChatCompletions(Player player) {

2
settings.gradle.kts
View File

@ -11,7 +11,7 @@ dependencyResolutionManagement {
repositories { repositories {
// mavenLocal() // mavenLocal()
mavenCentral() mavenCentral()
// maven("https://repo.destro.xyz/snapshots") // Altitude - Galaxy maven("https://repo.destro.xyz/snapshots") // Altitude - Galaxy
maven("https://oss.sonatype.org/content/groups/public/") // Adventure maven("https://oss.sonatype.org/content/groups/public/") // Adventure
maven("https://oss.sonatype.org/content/repositories/snapshots/") // Minimessage maven("https://oss.sonatype.org/content/repositories/snapshots/") // Minimessage
maven("https://nexus.velocitypowered.com/repository/") // Velocity maven("https://nexus.velocitypowered.com/repository/") // Velocity

6
velocity/build.gradle.kts
View File

@ -7,9 +7,9 @@ dependencies {
implementation(project(":api")) // API implementation(project(":api")) // API
compileOnly("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT") compileOnly("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT")
annotationProcessor("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT") annotationProcessor("com.velocitypowered:velocity-api:3.2.0-SNAPSHOT")
implementation("mysql:mysql-connector-java:8.0.27") // mysql implementation("mysql:mysql-connector-java:8.0.33") // mysql
implementation("org.spongepowered", "configurate-yaml", "4.1.2") implementation("org.spongepowered", "configurate-yaml", "4.2.0")
compileOnly("net.kyori:adventure-text-minimessage:4.10.1") compileOnly("net.kyori:adventure-text-minimessage:4.23.0")
compileOnly("com.gitlab.ruany:LiteBansAPI:0.3.5") compileOnly("com.gitlab.ruany:LiteBansAPI:0.3.5")
compileOnly("com.alttd.proxydiscordlink:ProxyDiscordLink:1.0.1-SNAPSHOT") compileOnly("com.alttd.proxydiscordlink:ProxyDiscordLink:1.0.1-SNAPSHOT")
} }

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

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

@ -16,8 +16,8 @@ import com.velocitypowered.api.proxy.Player;
import com.velocitypowered.api.proxy.ProxyServer; import com.velocitypowered.api.proxy.ProxyServer;
import com.velocitypowered.api.proxy.ServerConnection; import com.velocitypowered.api.proxy.ServerConnection;
import com.velocitypowered.api.proxy.server.RegisteredServer; import com.velocitypowered.api.proxy.server.RegisteredServer;
import jdk.jshell.execution.Util;
import net.kyori.adventure.text.Component; 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.Placeholder;
import java.time.Duration; import java.time.Duration;
@ -30,7 +30,7 @@ import java.util.stream.IntStream;
public class VoteToMuteHelper { public class VoteToMuteHelper {
private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>"); private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>").asComponent();
public VoteToMuteHelper(ProxyServer proxyServer) { public VoteToMuteHelper(ProxyServer proxyServer) {
RequiredArgumentBuilder<CommandSource, String> playerNode = RequiredArgumentBuilder RequiredArgumentBuilder<CommandSource, String> playerNode = RequiredArgumentBuilder
@ -51,8 +51,9 @@ public class VoteToMuteHelper {
.map(Player::getUsername) .map(Player::getUsername)
.toList(); .toList();
if (possibleValues.isEmpty()) if (possibleValues.isEmpty()) {
return Suggestions.empty(); return Suggestions.empty();
}
String remaining = builder.getRemaining().toLowerCase(); String remaining = builder.getRemaining().toLowerCase();
possibleValues.stream() possibleValues.stream()
@ -82,39 +83,39 @@ public class VoteToMuteHelper {
.<CommandSource>literal("page") .<CommandSource>literal("page")
.requires(commandSource -> commandSource.hasPermission("chat.vote-to-mute")) .requires(commandSource -> commandSource.hasPermission("chat.vote-to-mute"))
.then(RequiredArgumentBuilder.<CommandSource, Integer>argument("page number", IntegerArgumentType.integer(1)) .then(RequiredArgumentBuilder.<CommandSource, Integer>argument("page number", IntegerArgumentType.integer(1))
.suggests(((commandContext, suggestionsBuilder) -> { .suggests(((commandContext, suggestionsBuilder) -> {
if (!(commandContext.getSource() instanceof Player player)) { if (!(commandContext.getSource() instanceof Player player)) {
return suggestionsBuilder.buildFuture(); return suggestionsBuilder.buildFuture();
} }
Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId()); Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId());
if (instance.isEmpty()) { if (instance.isEmpty()) {
return suggestionsBuilder.buildFuture(); return suggestionsBuilder.buildFuture();
} }
VoteToMuteStarter voteToMuteStarter = instance.get(); VoteToMuteStarter voteToMuteStarter = instance.get();
String remaining = suggestionsBuilder.getRemaining().toLowerCase(); String remaining = suggestionsBuilder.getRemaining().toLowerCase();
int totalPages = voteToMuteStarter.getTotalPages(); int totalPages = voteToMuteStarter.getTotalPages();
IntStream.range(1, totalPages + 1) IntStream.range(1, totalPages + 1)
.mapToObj(String::valueOf) .mapToObj(String::valueOf)
.filter((String str) -> str.toLowerCase().startsWith(remaining)) .filter((String str) -> str.toLowerCase().startsWith(remaining))
.map(StringArgumentType::escapeIfRequired) .map(StringArgumentType::escapeIfRequired)
.forEach(suggestionsBuilder::suggest); .forEach(suggestionsBuilder::suggest);
return suggestionsBuilder.buildFuture(); return suggestionsBuilder.buildFuture();
})) }))
.executes(commandContext -> { .executes(commandContext -> {
if (!(commandContext.getSource() instanceof Player player)) { if (!(commandContext.getSource() instanceof Player player)) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Only players can use this command.</red>")); commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Only players can use this command.</red>"));
return 1; return 1;
} }
Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId()); Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId());
if (instance.isEmpty()) { if (instance.isEmpty()) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>You don't have an active vote to mute.</red>")); commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>You don't have an active vote to mute.</red>"));
return 1; return 1;
} }
int pageNumber = commandContext.getArgument("page number", Integer.class); int pageNumber = commandContext.getArgument("page number", Integer.class);
instance.get().showPage(pageNumber); instance.get().showPage(pageNumber);
return 1; return 1;
}) })
).executes(commandContext -> { ).executes(commandContext -> {
sendHelpMessage(commandContext.getSource()); sendHelpMessage(commandContext.getSource());
return 1; return 1;
}); });
@ -123,53 +124,53 @@ public class VoteToMuteHelper {
.<CommandSource>literal("messages") .<CommandSource>literal("messages")
.requires(commandSource -> commandSource.hasPermission("chat.vote-to-mute")) .requires(commandSource -> commandSource.hasPermission("chat.vote-to-mute"))
.then(RequiredArgumentBuilder.<CommandSource, String>argument("list of messages", StringArgumentType.greedyString()) .then(RequiredArgumentBuilder.<CommandSource, String>argument("list of messages", StringArgumentType.greedyString())
.executes(commandContext -> { .executes(commandContext -> {
if (!(commandContext.getSource() instanceof Player player)) { if (!(commandContext.getSource() instanceof Player player)) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Only players can use this command.</red>")); commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Only players can use this command.</red>"));
return 1; return 1;
} }
Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId()); Optional<VoteToMuteStarter> instance = VoteToMuteStarter.getInstance(player.getUniqueId());
if (instance.isEmpty()) { if (instance.isEmpty()) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>You don't have an active vote to mute.</red>")); commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>You don't have an active vote to mute.</red>"));
return 1; return 1;
} }
String listOfPages = commandContext.getArgument("list of messages", String.class); String listOfPages = commandContext.getArgument("list of messages", String.class);
if (!listOfPages.matches("([1-9][0-9]*, )*[1-9][0-9]*")) { 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>")); commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Please make sure to format the command correctly.</red>"));
return 1; return 1;
} }
VoteToMuteStarter voteToMuteStarter = instance.get(); VoteToMuteStarter voteToMuteStarter = instance.get();
List<Integer> collect = Arrays.stream(listOfPages.split(", ")) List<Integer> collect = Arrays.stream(listOfPages.split(", "))
.map(Integer::parseInt) .map(Integer::parseInt)
.collect(Collectors.toList()); .collect(Collectors.toList());
Optional<Integer> max = collect.stream().max(Integer::compare); Optional<Integer> max = collect.stream().max(Integer::compare);
if (max.isEmpty()) { if (max.isEmpty()) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Some of your selected messages do not exist.</red>")); commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Some of your selected messages do not exist.</red>"));
return 1; return 1;
} }
int highestLogEntry = max.get(); int highestLogEntry = max.get();
if (voteToMuteStarter.getTotalLogEntries() < highestLogEntry) { if (voteToMuteStarter.getTotalLogEntries() < highestLogEntry) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Some of your selected messages do not exist.</red>")); commandContext.getSource().sendMessage(Utility.parseMiniMessage("<red>Some of your selected messages do not exist.</red>"));
return 1; return 1;
} }
Optional<ServerConnection> currentServer = player.getCurrentServer(); Optional<ServerConnection> currentServer = player.getCurrentServer();
if (currentServer.isEmpty()) { if (currentServer.isEmpty()) {
sendHelpMessage(commandContext.getSource()); sendHelpMessage(commandContext.getSource());
return 1; return 1;
} }
Component chatLogs = voteToMuteStarter.getChatLogsAndClose(collect); Component chatLogs = voteToMuteStarter.getChatLogsAndClose(collect);
RegisteredServer server = currentServer.get().getServer(); RegisteredServer server = currentServer.get().getServer();
long count = getTotalEligiblePlayers(server, voteToMuteStarter.countLowerRanks()); long count = getTotalEligiblePlayers(server, voteToMuteStarter.countLowerRanks());
new ActiveVoteToMute(voteToMuteStarter.getVotedPlayer(), server, proxyServer, Duration.ofMinutes(5), new ActiveVoteToMute(voteToMuteStarter.getVotedPlayer(), server, proxyServer, Duration.ofMinutes(5),
(int) count, voteToMuteStarter.countLowerRanks(), chatLogs, player) (int) count, voteToMuteStarter.countLowerRanks(), chatLogs, player)
.start(); .start();
return 1; return 1;
}) })
).executes(commandContext -> { ).executes(commandContext -> {
sendHelpMessage(commandContext.getSource()); sendHelpMessage(commandContext.getSource());
return 1; return 1;
}); });
@ -177,47 +178,48 @@ public class VoteToMuteHelper {
LiteralArgumentBuilder<CommandSource> voteNode = LiteralArgumentBuilder LiteralArgumentBuilder<CommandSource> voteNode = LiteralArgumentBuilder
.<CommandSource>literal("vote") .<CommandSource>literal("vote")
.then(playerNode .then(playerNode
.then(yesNoNode .then(yesNoNode
.executes(commandContext -> { .executes(commandContext -> {
if (!(commandContext.getSource() instanceof Player player)) { if (!(commandContext.getSource() instanceof Player player)) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage( commandContext.getSource().sendMessage(Utility.parseMiniMessage(
"<red>Only players are allowed to vote</red>")); "<red>Only players are allowed to vote</red>"));
return 1; return 1;
} }
String playerName = commandContext.getArgument("player", String.class); String playerName = commandContext.getArgument("player", String.class);
Optional<ActiveVoteToMute> optionalActiveVoteToMute = ActiveVoteToMute.getInstance(playerName); Optional<ActiveVoteToMute> optionalActiveVoteToMute = ActiveVoteToMute.getInstance(playerName);
if (optionalActiveVoteToMute.isEmpty()) { if (optionalActiveVoteToMute.isEmpty()) {
commandContext.getSource().sendMessage(Utility.parseMiniMessage( commandContext.getSource().sendMessage(Utility.parseMiniMessage(
"<red>This player does not have an active vote to mute them.</red>")); "<red>This player does not have an active vote to mute them.</red>"));
return 1; return 1;
} }
ActiveVoteToMute activeVoteToMute = optionalActiveVoteToMute.get(); ActiveVoteToMute activeVoteToMute = optionalActiveVoteToMute.get();
if (!activeVoteToMute.countLowerRanks()) { if (!activeVoteToMute.countLowerRanks()) {
if (!player.hasPermission("chat.vote-to-mute")) { if (!player.hasPermission("chat.vote-to-mute")) {
player.sendMessage(Utility.parseMiniMessage("<red>You are not eligible to vote.</red>")); player.sendMessage(Utility.parseMiniMessage("<red>You are not eligible to vote.</red>"));
return 1; return 1;
} }
} }
String vote = commandContext.getArgument("yesNo", String.class); String vote = commandContext.getArgument("yesNo", String.class);
switch (vote.toLowerCase()) { switch (vote.toLowerCase()) {
case "yes" -> { case "yes" -> {
activeVoteToMute.vote(player.getUniqueId(), true); activeVoteToMute.vote(player.getUniqueId(), true);
commandContext.getSource().sendMessage(Utility.parseMiniMessage( commandContext.getSource().sendMessage(Utility.parseMiniMessage(
"<green>You voted to mute. Thanks for voting, staff will be online soon to review!</green>")); "<green>You voted to mute. Thanks for voting, staff will be online soon to review!</green>"));
player.getCurrentServer().ifPresent(serverConnection -> notifyEligiblePlayers(serverConnection.getServer(), activeVoteToMute)); player.getCurrentServer().ifPresent(serverConnection -> notifyEligiblePlayers(serverConnection.getServer(), activeVoteToMute));
} }
case "no" -> { case "no" -> {
activeVoteToMute.vote(player.getUniqueId(), false); activeVoteToMute.vote(player.getUniqueId(), false);
commandContext.getSource().sendMessage(Utility.parseMiniMessage( commandContext.getSource().sendMessage(Utility.parseMiniMessage(
"<green>You voted <red>not</red> to mute. Thanks for voting, staff will be online soon to review!</green>")); "<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( default ->
"<red><vote> is not a valid vote option</red>", Placeholder.parsed("vote", vote))); commandContext.getSource().sendMessage(Utility.parseMiniMessage(
} "<red><vote> is not a valid vote option</red>", Placeholder.parsed("vote", vote)));
return 1; }
})).executes(context -> { return 1;
})).executes(context -> {
sendHelpMessage(context.getSource()); sendHelpMessage(context.getSource());
return 1; return 1;
})).executes(context -> { })).executes(context -> {
@ -254,14 +256,14 @@ public class VoteToMuteHelper {
} }
private void notifyEligiblePlayers(RegisteredServer server, ActiveVoteToMute activeVoteToMute) { private void notifyEligiblePlayers(RegisteredServer server, ActiveVoteToMute activeVoteToMute) {
Component message = Utility.parseMiniMessage("<prefix><green><voted_for> out of <total_votes> players have voted to mute <player></green>", ComponentLike message = Utility.parseMiniMessage("<prefix><green><voted_for> out of <total_votes> players have voted to mute <player></green>",
Placeholder.component("prefix", prefix), Placeholder.component("prefix", prefix),
Placeholder.parsed("voted_for", String.valueOf(activeVoteToMute.getVotedFor())), Placeholder.parsed("voted_for", String.valueOf(activeVoteToMute.getVotedFor())),
Placeholder.parsed("total_votes", String.valueOf(activeVoteToMute.getTotalEligibleVoters())), Placeholder.parsed("total_votes", String.valueOf(activeVoteToMute.getTotalEligibleVoters())),
Placeholder.parsed("player", activeVoteToMute.getVotedPlayer().getUsername())); Placeholder.parsed("player", activeVoteToMute.getVotedPlayer().getUsername()));
boolean countLowerRanks = activeVoteToMute.countLowerRanks(); boolean countLowerRanks = activeVoteToMute.countLowerRanks();
server.getPlayersConnected().stream() server.getPlayersConnected().stream()
.filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute")) .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
.forEach(player -> player.sendMessage(message)); .forEach(player -> player.sendMessage(message));
} }

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

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

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

@ -40,19 +40,20 @@ public class Info implements SubCommand {
List<Component> displayNames = new ArrayList<>(); List<Component> displayNames = new ArrayList<>();
for (PartyUser partyUser : party.getPartyUsers()) { for (PartyUser partyUser : party.getPartyUsers()) {
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(partyUser.getUuid()); Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(partyUser.getUuid());
if (optionalPlayer.isPresent() && optionalPlayer.get().isActive()) if (optionalPlayer.isPresent() && optionalPlayer.get().isActive()) {
displayNames.add(Config.ONLINE_PREFIX.append(partyUser.getDisplayName())); displayNames.add(Config.ONLINE_PREFIX.asComponent().append(partyUser.getDisplayName()));
else } else {
displayNames.add(Config.OFFLINE_PREFIX.append(partyUser.getDisplayName())); displayNames.add(Config.OFFLINE_PREFIX.asComponent().append(partyUser.getDisplayName()));
}
} }
PartyUser owner = party.getPartyUser(party.getOwnerUuid()); PartyUser owner = party.getPartyUser(party.getOwnerUuid());
source.sendMessage(Utility.parseMiniMessage(Config.PARTY_INFO, source.sendMessage(Utility.parseMiniMessage(Config.PARTY_INFO,
Placeholder.unparsed("party", party.getPartyName()), Placeholder.unparsed("party", party.getPartyName()),
Placeholder.unparsed("password", party.getPartyPassword()), Placeholder.unparsed("password", party.getPartyPassword()),
Placeholder.component("owner", owner == null ? MiniMessage.miniMessage().deserialize("Unknown Owner") : owner.getDisplayName()), Placeholder.component("owner", owner == null ? MiniMessage.miniMessage().deserialize("Unknown Owner") : owner.getDisplayName()),
Placeholder.component("members", Component.join(JoinConfiguration.separator(Component.text(", ")), displayNames)) Placeholder.component("members", Component.join(JoinConfiguration.separator(Component.text(", ")), displayNames))
)); ));
} }
@Override @Override

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

@ -43,7 +43,7 @@ public class Join implements SubCommand {
return; return;
} }
// party.addUser(ChatUserManager.getChatUser(player.getUniqueId())); //Removed until we can get nicknames to translate to colors correctly // party.addUser(ChatUserManager.getChatUser(player.getUniqueId())); //Removed until we can get nicknames to translate to colors correctly
ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId()); ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId());
if (chatUser.getPartyId() == party.getPartyId()) { if (chatUser.getPartyId() == party.getPartyId()) {
@ -52,11 +52,12 @@ public class Join implements SubCommand {
} }
party.addUser(chatUser, player.getUsername()); party.addUser(chatUser, player.getUsername());
source.sendMessage(Utility.parseMiniMessage(Config.JOINED_PARTY, Placeholder.parsed("party_name", party.getPartyName()))); source.sendMessage(Utility.parseMiniMessage(Config.JOINED_PARTY, Placeholder.parsed("party_name", party.getPartyName())));
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party, VelocityChat.getPlugin().getChatHandler()
Utility.parseMiniMessage(Config.PLAYER_JOINED_PARTY, .sendPartyMessage(party,
Placeholder.component("player_name", chatUser.getDisplayName()), Utility.parseMiniMessage(Config.PLAYER_JOINED_PARTY,
Placeholder.parsed("party_name", party.getPartyName()) Placeholder.component("player_name", chatUser.getDisplayName()),
), null); Placeholder.parsed("party_name", party.getPartyName())
).asComponent(), null);
} }
@Override @Override

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

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

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

@ -45,18 +45,19 @@ public class Name implements SubCommand {
} }
if (PartyManager.getParty(args[1]) != null) { if (PartyManager.getParty(args[1]) != null) {
source.sendMessage(Utility.parseMiniMessage(Config.PARTY_EXISTS, source.sendMessage(Utility.parseMiniMessage(Config.PARTY_EXISTS,
Placeholder.unparsed("party", args[1]) Placeholder.unparsed("party", args[1])
)); ));
return; return;
} }
String oldName = party.getPartyName(); String oldName = party.getPartyName();
party.setPartyName(args[1]); party.setPartyName(args[1]);
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party, Utility.parseMiniMessage(Config.RENAMED_PARTY, VelocityChat.getPlugin().getChatHandler()
Placeholder.component("owner", ChatUserManager.getChatUser(player.getUniqueId()).getDisplayName()), .sendPartyMessage(party, Utility.parseMiniMessage(Config.RENAMED_PARTY,
Placeholder.unparsed("old_name", oldName), Placeholder.component("owner", ChatUserManager.getChatUser(player.getUniqueId()).getDisplayName()),
Placeholder.unparsed("new_name", args[1]) Placeholder.unparsed("old_name", oldName),
), null); Placeholder.unparsed("new_name", args[1])
).asComponent(), null);
} }
@Override @Override

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

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

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

@ -10,6 +10,7 @@ import com.velocitypowered.api.proxy.ProxyServer;
import com.velocitypowered.api.proxy.ServerConnection; import com.velocitypowered.api.proxy.ServerConnection;
import com.velocitypowered.api.proxy.server.RegisteredServer; import com.velocitypowered.api.proxy.server.RegisteredServer;
import net.kyori.adventure.text.Component; 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.Placeholder;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
@ -25,12 +26,12 @@ import java.util.stream.Collectors;
public class ActiveVoteToMute { public class ActiveVoteToMute {
private static final HashMap<String, ActiveVoteToMute> instances = new HashMap<>(); private static final HashMap<String, ActiveVoteToMute> instances = new HashMap<>();
private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>"); private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>").asComponent();
private final Player votedPlayer; private final Player votedPlayer;
private final Player startedByPlayer; private final Player startedByPlayer;
private HashSet<UUID> votedFor = new HashSet<>(); private final HashSet<UUID> votedFor = new HashSet<>();
private HashSet<UUID> votedAgainst = new HashSet<>(); private final HashSet<UUID> votedAgainst = new HashSet<>();
private int totalEligibleVoters; private int totalEligibleVoters;
private final boolean countLowerRanks; private final boolean countLowerRanks;
private final RegisteredServer server; private final RegisteredServer server;
@ -39,14 +40,16 @@ public class ActiveVoteToMute {
private boolean endedVote = false; private boolean endedVote = false;
public static Optional<ActiveVoteToMute> getInstance(String username) { public static Optional<ActiveVoteToMute> getInstance(String username) {
if (!instances.containsKey(username)) if (!instances.containsKey(username)) {
return Optional.empty(); return Optional.empty();
}
return Optional.of(instances.get(username)); return Optional.of(instances.get(username));
} }
public static void removePotentialVoter(Player player, RegisteredServer previousServer) { public static void removePotentialVoter(Player player, RegisteredServer previousServer) {
if (!player.hasPermission("chat.backup-vote-to-mute")) if (!player.hasPermission("chat.backup-vote-to-mute")) {
return; return;
}
if (player.hasPermission("chat.vote-to-mute")) { if (player.hasPermission("chat.vote-to-mute")) {
instances.values().stream() instances.values().stream()
.filter(activeVoteToMute -> previousServer == null || activeVoteToMute.getServer().getServerInfo().hashCode() == previousServer.getServerInfo().hashCode()) .filter(activeVoteToMute -> previousServer == null || activeVoteToMute.getServer().getServerInfo().hashCode() == previousServer.getServerInfo().hashCode())
@ -60,8 +63,9 @@ public class ActiveVoteToMute {
} }
public static void addPotentialVoter(Player player, ServerConnection server) { public static void addPotentialVoter(Player player, ServerConnection server) {
if (!player.hasPermission("chat.backup-vote-to-mute")) if (!player.hasPermission("chat.backup-vote-to-mute")) {
return; return;
}
if (player.hasPermission("chat.vote-to-mute")) { if (player.hasPermission("chat.vote-to-mute")) {
instances.values().stream() instances.values().stream()
.filter(activeVoteToMute -> activeVoteToMute.getServer().getServerInfo().hashCode() == server.getServerInfo().hashCode()) .filter(activeVoteToMute -> activeVoteToMute.getServer().getServerInfo().hashCode() == server.getServerInfo().hashCode())
@ -85,7 +89,7 @@ public class ActiveVoteToMute {
instances.put(votedPlayer.getUsername(), this); instances.put(votedPlayer.getUsername(), this);
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(); ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
executorService.schedule(this::endVote, executorService.schedule(this::endVote,
duration.toMinutes(), TimeUnit.MINUTES); duration.toMinutes(), TimeUnit.MINUTES);
this.startedByPlayer = startedByPlayer; this.startedByPlayer = startedByPlayer;
} }
@ -94,22 +98,23 @@ public class ActiveVoteToMute {
} }
private void endVote() { private void endVote() {
if (endedVote) if (endedVote) {
return; return;
}
instances.remove(votedPlayer.getUsername()); instances.remove(votedPlayer.getUsername());
if (votePassed()) { if (votePassed()) {
mutePlayer(); mutePlayer();
return; return;
} }
Component message = Utility.parseMiniMessage("<prefix> <red>The vote to mute <player> has failed, they will not be muted.</red>", 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())); Placeholder.component("prefix", prefix), Placeholder.parsed("player", votedPlayer.getUsername()));
server.getPlayersConnected().stream() server.getPlayersConnected().stream()
.filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute")) .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
.forEach(player -> player.sendMessage(message)); .forEach(player -> player.sendMessage(message));
} }
public void start() { public void start() {
Component message = getVoteStartMessage(); ComponentLike message = getVoteStartMessage();
server.getPlayersConnected().stream() server.getPlayersConnected().stream()
.filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute")) .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
.forEach(player -> player.sendMessage(message)); .forEach(player -> player.sendMessage(message));
@ -147,24 +152,23 @@ public class ActiveVoteToMute {
} }
private void mutePlayer() { private void mutePlayer() {
Component message = Utility.parseMiniMessage("<prefix> <green>The vote to mute <player> has passed, they will be muted.</green>", 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())); Placeholder.component("prefix", prefix), Placeholder.parsed("player", votedPlayer.getUsername()));
server.getPlayersConnected().stream() server.getPlayersConnected().stream()
.filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute")) .filter(player -> countLowerRanks ? player.hasPermission("chat.backup-vote-to-mute") : player.hasPermission("chat.vote-to-mute"))
.forEach(player -> player.sendMessage(message)); .forEach(player -> player.sendMessage(message));
proxyServer.getCommandManager().executeAsync(proxyServer.getConsoleCommandSource(), proxyServer.getCommandManager().executeAsync(proxyServer.getConsoleCommandSource(),
String.format("tempmute %s 1h Muted by the community - under review. -p", votedPlayer.getUsername())); String.format("tempmute %s 1h Muted by the community - under review. -p", votedPlayer.getUsername()));
String chatLogsString = PlainTextComponentSerializer.plainText().serialize(chatLogs); String chatLogsString = PlainTextComponentSerializer.plainText().serialize(chatLogs);
EmbedBuilder embedBuilder = buildMutedEmbed(chatLogsString); 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", ALogger.info(String.format("Player %s muted by vote\nLogs:\n%s\n\nVotes for:\n%s\nVotes against:\n%s\n",
votedPlayer.getUsername(), votedPlayer.getUsername(),
chatLogsString, chatLogsString,
parseUUIDsToPlayerOrString(votedFor), parseUUIDsToPlayerOrString(votedFor),
parseUUIDsToPlayerOrString(votedAgainst) parseUUIDsToPlayerOrString(votedAgainst)
)); ));
long id = Config.serverChannelId.get("general"); long id = Config.serverChannelId.get("general");
DiscordLink.getPlugin().getBot().sendEmbedToDiscord(id, embedBuilder, -1); DiscordLink.getPlugin().getBot().sendEmbedToDiscord(id, embedBuilder, -1);
@ -177,14 +181,14 @@ public class ActiveVoteToMute {
embedBuilder.setTitle("Player muted by vote"); embedBuilder.setTitle("Player muted by vote");
embedBuilder.setColor(Color.CYAN); embedBuilder.setColor(Color.CYAN);
embedBuilder.addField("Logs", embedBuilder.addField("Logs",
chatLogsString.substring(0, Math.min(chatLogsString.length(), 1024)), chatLogsString.substring(0, Math.min(chatLogsString.length(), 1024)),
false); false);
embedBuilder.addField("Server", embedBuilder.addField("Server",
server.getServerInfo().getName().substring(0, 1).toUpperCase() + server.getServerInfo().getName().substring(1), server.getServerInfo().getName().substring(0, 1).toUpperCase() + server.getServerInfo().getName().substring(1),
true); true);
embedBuilder.addField("Started by", embedBuilder.addField("Started by",
String.format("Username: %s\nUUID: %s", startedByPlayer.getUsername(), startedByPlayer.getUniqueId().toString()), String.format("Username: %s\nUUID: %s", startedByPlayer.getUsername(), startedByPlayer.getUniqueId().toString()),
true); true);
return embedBuilder; return embedBuilder;
} }
@ -200,25 +204,27 @@ public class ActiveVoteToMute {
public void addEligibleVoter(Player player) { public void addEligibleVoter(Player player) {
UUID uuid = player.getUniqueId(); UUID uuid = player.getUniqueId();
if (votedAgainst.contains(uuid) || votedFor.contains(uuid)) if (votedAgainst.contains(uuid) || votedFor.contains(uuid)) {
return; return;
}
totalEligibleVoters++; totalEligibleVoters++;
player.sendMessage(getVoteStartMessage()); player.sendMessage(getVoteStartMessage());
} }
public void removeEligibleVoter(UUID uuid) { public void removeEligibleVoter(UUID uuid) {
if (votedFor.contains(uuid) || votedAgainst.contains(uuid)) if (votedFor.contains(uuid) || votedAgainst.contains(uuid)) {
return; return;
}
totalEligibleVoters--; totalEligibleVoters--;
} }
private Component getVoteStartMessage() { private ComponentLike getVoteStartMessage() {
return Utility.parseMiniMessage( return Utility.parseMiniMessage(
String.format(""" String.format("""
<prefix> <green>A vote to mute <player> for one hour has been started, please read the logs below before voting.</green> <prefix> <green>A vote to mute <player> for one hour has been started, please read the logs below before voting.</green>
<logs> <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>""", <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()), votedPlayer.getUsername(), votedPlayer.getUsername()),
Placeholder.component("prefix", prefix), Placeholder.component("prefix", prefix),
Placeholder.parsed("player", votedPlayer.getUsername()), Placeholder.parsed("player", votedPlayer.getUsername()),
Placeholder.component("logs", chatLogs)); Placeholder.component("logs", chatLogs));

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

@ -18,7 +18,7 @@ public class VoteToMuteStarter {
private static final HashMap<UUID, VoteToMuteStarter> instanceMap = new HashMap<>(); private static final HashMap<UUID, VoteToMuteStarter> instanceMap = new HashMap<>();
private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>"); private static final Component prefix = Utility.parseMiniMessage("<gold>[VoteMute]</gold>").asComponent();
private final ChatLogHandler chatLogHandler; private final ChatLogHandler chatLogHandler;
private final Player votedPlayer; private final Player votedPlayer;
private final Player commandSource; private final Player commandSource;
@ -27,8 +27,9 @@ public class VoteToMuteStarter {
private final boolean countLowerRanks; private final boolean countLowerRanks;
public static Optional<VoteToMuteStarter> getInstance(UUID uuid) { public static Optional<VoteToMuteStarter> getInstance(UUID uuid) {
if (!instanceMap.containsKey(uuid)) if (!instanceMap.containsKey(uuid)) {
return Optional.empty(); return Optional.empty();
}
return Optional.of(instanceMap.get(uuid)); return Optional.of(instanceMap.get(uuid));
} }
@ -45,14 +46,14 @@ public class VoteToMuteStarter {
chatLogHandler.retrieveChatLogs(votedPlayer.getUniqueId(), Duration.ofMinutes(10), serverName).whenCompleteAsync((chatLogs, throwable) -> { chatLogHandler.retrieveChatLogs(votedPlayer.getUniqueId(), Duration.ofMinutes(10), serverName).whenCompleteAsync((chatLogs, throwable) -> {
if (throwable != null) { if (throwable != null) {
commandSource.sendMessage(Utility.parseMiniMessage("<prefix> <red>Unable to retrieve messages</red> for player <player>", commandSource.sendMessage(Utility.parseMiniMessage("<prefix> <red>Unable to retrieve messages</red> for player <player>",
Placeholder.component("prefix", prefix), Placeholder.component("prefix", prefix),
Placeholder.parsed("player", votedPlayer.getUsername()))); Placeholder.parsed("player", votedPlayer.getUsername())));
return; return;
} }
parseChatLogs(chatLogs); parseChatLogs(chatLogs);
commandSource.sendMessage(Utility.parseMiniMessage( commandSource.sendMessage(Utility.parseMiniMessage(
"<prefix> <green>Please select up to 10 messages other players should see to decide their vote, seperated by comma's. " + "<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))); "Example: <gold>/votetomutehelper messages 1, 2, 5, 8</gold></green>", Placeholder.component("prefix", prefix)));
showPage(1); showPage(1);
}); });
} }
@ -63,13 +64,14 @@ public class VoteToMuteStarter {
chatLogs.sort(Comparator.comparing(ChatLog::getTimestamp).reversed()); chatLogs.sort(Comparator.comparing(ChatLog::getTimestamp).reversed());
parsedChatLogs = IntStream.range(0, chatLogs.size()) parsedChatLogs = IntStream.range(0, chatLogs.size())
.mapToObj(i -> Utility.parseMiniMessage( .mapToObj(i -> Utility.parseMiniMessage(
"<number>. <prefix> <player>: <message>", "<number>. <prefix> <player>: <message>",
TagResolver.resolver( TagResolver.resolver(
Placeholder.unparsed("message", chatLogs.get(i).getMessage()), Placeholder.unparsed("message", chatLogs.get(i).getMessage()),
Placeholder.parsed("number", String.valueOf(i + 1)), Placeholder.parsed("number", String.valueOf(i + 1)),
playerTag, prefixTag playerTag,
)) prefixTag
) )).asComponent()
)
.toList(); .toList();
} }
@ -89,16 +91,17 @@ public class VoteToMuteStarter {
.append("><hover:show_text:'<gold>Click to go to next page'><gold><next page></gold></hover></click> "); .append("><hover:show_text:'<gold>Click to go to next page'><gold><next page></gold></hover></click> ");
} }
commandSource.sendMessage(Utility.parseMiniMessage(stringBuilder.toString(), commandSource.sendMessage(Utility.parseMiniMessage(stringBuilder.toString(),
Placeholder.parsed("player", votedPlayer.getUsername()), Placeholder.parsed("player", votedPlayer.getUsername()),
Placeholder.component("prefix", prefix), Placeholder.component("prefix", prefix),
Placeholder.component("logs", chatLogsComponent))); Placeholder.component("logs", chatLogsComponent)));
} }
/** /**
* Retrieves the chat logs for the given list of IDs. It removes 1 from the IDs before using them * Retrieves the chat logs for the given list of IDs. It removes 1 from the IDs before using them It removes the
* It removes the instance from the hashmap after this function call * instance from the hashmap after this function call
* *
* @param ids A list of integers representing the IDs of the chat logs to retrieve. * @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. * @return A Component object containing the selected chat logs joined by newlines.
*/ */
public Component getChatLogsAndClose(List<Integer> ids) { public Component getChatLogsAndClose(List<Integer> ids) {

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

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

@ -15,6 +15,7 @@ import com.velocitypowered.api.command.CommandSource;
import com.velocitypowered.api.proxy.Player; import com.velocitypowered.api.proxy.Player;
import com.velocitypowered.api.proxy.ServerConnection; import com.velocitypowered.api.proxy.ServerConnection;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.TextReplacementConfig; import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder; import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
@ -24,7 +25,10 @@ import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.time.Duration; import java.time.Duration;
import java.util.*; import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
public class ChatHandler { public class ChatHandler {
@ -32,11 +36,15 @@ public class ChatHandler {
UUID uuid = UUID.fromString(sender); UUID uuid = UUID.fromString(sender);
ChatUser senderUser = ChatUserManager.getChatUser(uuid); ChatUser senderUser = ChatUserManager.getChatUser(uuid);
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid); Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid);
if(optionalPlayer.isEmpty()) return; if (optionalPlayer.isEmpty()) {
return;
}
Player player = optionalPlayer.get(); Player player = optionalPlayer.get();
Optional<Player> optionalPlayer2 = VelocityChat.getPlugin().getProxy().getPlayer(target); Optional<Player> optionalPlayer2 = VelocityChat.getPlugin().getProxy().getPlayer(target);
if(optionalPlayer2.isEmpty()) return; if (optionalPlayer2.isEmpty()) {
return;
}
Player player2 = optionalPlayer2.get(); Player player2 = optionalPlayer2.get();
ChatUser targetUser = ChatUserManager.getChatUser(player2.getUniqueId()); ChatUser targetUser = ChatUserManager.getChatUser(player2.getUniqueId());
@ -49,12 +57,12 @@ public class ChatHandler {
Placeholder.unparsed("server", player.getCurrentServer().isPresent() ? player.getCurrentServer().get().getServerInfo().getName() : "Altitude")); Placeholder.unparsed("server", player.getCurrentServer().isPresent() ? player.getCurrentServer().get().getServerInfo().getName() : "Altitude"));
ServerConnection serverConnection; ServerConnection serverConnection;
if(player.getCurrentServer().isPresent() && player2.getCurrentServer().isPresent()) { if (player.getCurrentServer().isPresent() && player2.getCurrentServer().isPresent()) {
// redirect to the sender // redirect to the sender
serverConnection = player.getCurrentServer().get(); serverConnection = player.getCurrentServer().get();
Component component = Utility.parseMiniMessage(Config.MESSAGESENDER Component component = Utility.parseMiniMessage(Config.MESSAGESENDER
.replaceAll("<sendername>", player.getUsername()) .replaceAll("<sendername>", player.getUsername())
.replaceAll("<receivername>", player2.getUsername()), Placeholders); .replaceAll("<receivername>", player2.getUsername()), Placeholders).asComponent();
ByteArrayDataOutput buf = ByteStreams.newDataOutput(); ByteArrayDataOutput buf = ByteStreams.newDataOutput();
buf.writeUTF("privatemessageout"); buf.writeUTF("privatemessageout");
buf.writeUTF(player.getUniqueId().toString()); buf.writeUTF(player.getUniqueId().toString());
@ -66,8 +74,8 @@ public class ChatHandler {
//redirect to the receiver //redirect to the receiver
serverConnection = player2.getCurrentServer().get(); serverConnection = player2.getCurrentServer().get();
component = Utility.parseMiniMessage(Config.MESSAGERECIEVER component = Utility.parseMiniMessage(Config.MESSAGERECIEVER
.replaceAll("<sendername>", player.getUsername()) .replaceAll("<sendername>", player.getUsername())
.replaceAll("<receivername>", player2.getUsername()), Placeholders); .replaceAll("<receivername>", player2.getUsername()), Placeholders).asComponent();
buf = ByteStreams.newDataOutput(); buf = ByteStreams.newDataOutput();
buf.writeUTF("privatemessagein"); buf.writeUTF("privatemessagein");
buf.writeUTF(player2.getUniqueId().toString()); buf.writeUTF(player2.getUniqueId().toString());
@ -85,25 +93,25 @@ public class ChatHandler {
Placeholder.parsed("displayname", Utility.getDisplayName(player.getUniqueId(), player.getUsername())), Placeholder.parsed("displayname", Utility.getDisplayName(player.getUniqueId(), player.getUsername())),
Placeholder.unparsed("target", (target.isEmpty() ? " tried to say: " : " -> " + target + ": ")), Placeholder.unparsed("target", (target.isEmpty() ? " tried to say: " : " -> " + target + ": ")),
Placeholder.unparsed("input", input) Placeholder.unparsed("input", input)
); );
Component blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, Placeholders); ComponentLike blockedNotification = Utility.parseMiniMessage(Config.NOTIFICATIONFORMAT, Placeholders);
serverConnection.getServer().getPlayersConnected().forEach(pl ->{ serverConnection.getServer().getPlayersConnected().forEach(pl -> {
if (pl.hasPermission("chat.alert-blocked")) { if (pl.hasPermission("chat.alert-blocked")) {
pl.sendMessage(blockedNotification); pl.sendMessage(blockedNotification);
} }
}); });
player.sendMessage(Utility.parseMiniMessage("<red>The language you used in your message is not allowed, " + 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>")); "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() VelocityChat.getPlugin().getProxy().getAllPlayers().stream()
.filter(pl -> { .filter(pl -> {
UUID uuid = pl.getUniqueId(); UUID uuid = pl.getUniqueId();
if (ignoredPlayers != null && ignoredPlayers.contains(uuid)) if (ignoredPlayers != null && ignoredPlayers.contains(uuid)) {
return false; return false;
}
return party.getPartyUsers().stream().anyMatch(pu -> pu.getUuid().equals(uuid)); return party.getPartyUsers().stream().anyMatch(pu -> pu.getUuid().equals(uuid));
}).forEach(pl -> { }).forEach(pl -> {
pl.sendMessage(message); pl.sendMessage(message);
@ -114,7 +122,9 @@ public class ChatHandler {
public void sendPartyMessage(UUID uuid, String message, Component item, ServerConnection serverConnection) { public void sendPartyMessage(UUID uuid, String message, Component item, ServerConnection serverConnection) {
Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid); Optional<Player> optionalPlayer = VelocityChat.getPlugin().getProxy().getPlayer(uuid);
if (optionalPlayer.isEmpty()) return; if (optionalPlayer.isEmpty()) {
return;
}
Player player = optionalPlayer.get(); Player player = optionalPlayer.get();
ChatUser user = ChatUserManager.getChatUser(uuid); ChatUser user = ChatUserManager.getChatUser(uuid);
Party party = PartyManager.getParty(user.getPartyId()); Party party = PartyManager.getParty(user.getPartyId());
@ -122,7 +132,7 @@ public class ChatHandler {
player.sendMessage(Utility.parseMiniMessage(Config.NOT_IN_A_PARTY)); player.sendMessage(Utility.parseMiniMessage(Config.NOT_IN_A_PARTY));
return; return;
} }
Component senderName = user.getDisplayName(); ComponentLike senderName = user.getDisplayName();
TagResolver Placeholders = TagResolver.resolver( TagResolver Placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName), Placeholder.component("sender", senderName),
@ -130,9 +140,9 @@ public class ChatHandler {
Placeholder.unparsed("partyname", party.getPartyName()), Placeholder.unparsed("partyname", party.getPartyName()),
Placeholder.component("message", parseMessageContent(player, message)), Placeholder.component("message", parseMessageContent(player, message)),
Placeholder.unparsed("server", serverConnection.getServer().getServerInfo().getName()) Placeholder.unparsed("server", serverConnection.getServer().getServerInfo().getName())
); );
Component partyMessage = Utility.parseMiniMessage(Config.PARTY_FORMAT, Placeholders) Component partyMessage = Utility.parseMiniMessage(Config.PARTY_FORMAT, Placeholders).asComponent()
.replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(item).build()); .replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(item).build());
ModifiableString modifiableString = new ModifiableString(partyMessage); ModifiableString modifiableString = new ModifiableString(partyMessage);
@ -145,9 +155,9 @@ public class ChatHandler {
sendPartyMessage(party, partyMessage, user.getIgnoredBy()); sendPartyMessage(party, partyMessage, user.getIgnoredBy());
Component spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, Placeholders); ComponentLike spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, Placeholders);
for(Player pl : serverConnection.getServer().getPlayersConnected()) { for (Player pl : serverConnection.getServer().getPlayersConnected()) {
if(pl.hasPermission(Config.SPYPERMISSION) && !party.getPartyUsersUuid().contains(pl.getUniqueId())) { if (pl.hasPermission(Config.SPYPERMISSION) && !party.getPartyUsersUuid().contains(pl.getUniqueId())) {
pl.sendMessage(spyMessage); pl.sendMessage(spyMessage);
} }
} }
@ -157,18 +167,20 @@ public class ChatHandler {
public void globalAdminChat(String message) { public void globalAdminChat(String message) {
Component component = GsonComponentSerializer.gson().deserialize(message); Component component = GsonComponentSerializer.gson().deserialize(message);
VelocityChat.getPlugin().getProxy().getAllPlayers().stream().filter(target -> target.hasPermission("command.chat.globaladminchat")/*TODO permission*/).forEach(target -> { VelocityChat.getPlugin().getProxy().getAllPlayers()
target.sendMessage(component); .stream()
}); .filter(target -> target.hasPermission("command.chat.globaladminchat"))
.forEach(target -> target.sendMessage(component));
} }
public void globalAdminChat(CommandSource commandSource, String message) { public void globalAdminChat(CommandSource commandSource, String message) {
Component senderName = Component.text(Config.CONSOLENAME); ComponentLike senderName = Component.text(Config.CONSOLENAME);
String serverName = "Altitude"; String serverName = "Altitude";
if (commandSource instanceof Player) { if (commandSource instanceof Player sender) {
Player sender = (Player) commandSource;
ChatUser user = ChatUserManager.getChatUser(sender.getUniqueId()); ChatUser user = ChatUserManager.getChatUser(sender.getUniqueId());
if(user == null) return; if (user == null) {
return;
}
senderName = user.getDisplayName(); senderName = user.getDisplayName();
serverName = sender.getCurrentServer().isPresent() ? sender.getCurrentServer().get().getServerInfo().getName() : "Altitude"; serverName = sender.getCurrentServer().isPresent() ? sender.getCurrentServer().get().getServerInfo().getName() : "Altitude";
} }
@ -178,15 +190,16 @@ public class ChatHandler {
Placeholder.component("sender", senderName), Placeholder.component("sender", senderName),
Placeholder.unparsed("server", serverName)); Placeholder.unparsed("server", serverName));
Component component = Utility.parseMiniMessage(Config.GACFORMAT, Placeholders); ComponentLike component = Utility.parseMiniMessage(Config.GACFORMAT, Placeholders);
VelocityChat.getPlugin().getProxy().getAllPlayers().stream().filter(target -> target.hasPermission("command.chat.globaladminchat")/*TODO permission*/).forEach(target -> { VelocityChat.getPlugin().getProxy().getAllPlayers()
target.sendMessage(component); .stream()
}); .filter(target -> target.hasPermission("command.chat.globaladminchat"))
.forEach(target -> target.sendMessage(component));
} }
public void sendMail(CommandSource commandSource, String recipient, String message) { public void sendMail(CommandSource commandSource, String recipient, String message) {
UUID uuid = Config.CONSOLEUUID;; UUID uuid = Config.CONSOLEUUID;
String senderName = Config.CONSOLENAME; String senderName = Config.CONSOLENAME;
UUID targetUUID; UUID targetUUID;
if (commandSource instanceof Player player) { if (commandSource instanceof Player player) {
@ -248,7 +261,7 @@ public class ChatHandler {
} }
private Component parseMails(List<Mail> mails, boolean mark) { private Component parseMails(List<Mail> mails, boolean mark) {
Component component = Utility.parseMiniMessage(Config.mailHeader); Component component = Utility.parseMiniMessage(Config.mailHeader).asComponent();
for (Mail mail : mails) { for (Mail mail : mails) {
if (mail.isUnRead() && mark) { if (mail.isUnRead() && mark) {
mail.setReadTime(System.currentTimeMillis()); mail.setReadTime(System.currentTimeMillis());
@ -262,28 +275,14 @@ public class ChatHandler {
Placeholder.component("message", Utility.parseMiniMessage(mail.getMessage())), Placeholder.component("message", Utility.parseMiniMessage(mail.getMessage())),
Placeholder.unparsed("date", date.toString()), Placeholder.unparsed("date", date.toString()),
Placeholder.unparsed("time_ago", getTimeAgo(Duration.between(date.toInstant(), new Date().toInstant()))) Placeholder.unparsed("time_ago", getTimeAgo(Duration.between(date.toInstant(), new Date().toInstant())))
); );
Component mailMessage = Utility.parseMiniMessage(Config.mailBody, Placeholders); ComponentLike mailMessage = Utility.parseMiniMessage(Config.mailBody, Placeholders);
component = component.append(Component.newline()).append(mailMessage); component = component.append(Component.newline()).append(mailMessage);
} }
component = component.append(Component.newline()).append(Utility.parseMiniMessage(Config.mailFooter)); component = component.append(Component.newline()).append(Utility.parseMiniMessage(Config.mailFooter));
return component; 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) { public void mutePlayer(String uuid, boolean muted) {
ByteArrayDataOutput buf = ByteStreams.newDataOutput(); ByteArrayDataOutput buf = ByteStreams.newDataOutput();
buf.writeUTF("chatpunishments"); buf.writeUTF("chatpunishments");
@ -293,10 +292,12 @@ public class ChatHandler {
private String getTimeAgo(Duration duration) { private String getTimeAgo(Duration duration) {
StringBuilder stringBuilder = new StringBuilder(); StringBuilder stringBuilder = new StringBuilder();
if (duration.toDays() != 0) if (duration.toDays() != 0) {
stringBuilder.append(duration.toDays()).append("d "); 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.toHoursPart()).append("h ");
}
stringBuilder.append(duration.toMinutesPart()).append("m ago"); stringBuilder.append(duration.toMinutesPart()).append("m ago");
return stringBuilder.toString(); return stringBuilder.toString();
} }
@ -312,7 +313,7 @@ public class ChatHandler {
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build(); MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(rawMessage); Component component = miniMessage.deserialize(rawMessage);
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) { for (ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText( component = component.replaceText(
TextReplacementConfig.builder() TextReplacementConfig.builder()
.times(Config.EMOTELIMIT) .times(Config.EMOTELIMIT)

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

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

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

@ -1,16 +1,16 @@
package com.alttd.velocitychat.listeners; package com.alttd.velocitychat.listeners;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.ChatUserManager; import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.objects.ChatUser; import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Mail; import com.alttd.chat.objects.Mail;
import com.alttd.chat.objects.Party;
import com.alttd.chat.util.Utility; import com.alttd.chat.util.Utility;
import com.alttd.velocitychat.VelocityChat; import com.alttd.velocitychat.VelocityChat;
import com.alttd.chat.config.Config;
import com.alttd.velocitychat.commands.vote_to_mute.ActiveVoteToMute; import com.alttd.velocitychat.commands.vote_to_mute.ActiveVoteToMute;
import com.alttd.velocitychat.data.ServerWrapper; import com.alttd.velocitychat.data.ServerWrapper;
import com.alttd.velocitychat.handlers.ServerHandler; 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.PostOrder;
import com.velocitypowered.api.event.Subscribe; import com.velocitypowered.api.event.Subscribe;
import com.velocitypowered.api.event.connection.DisconnectEvent; import com.velocitypowered.api.event.connection.DisconnectEvent;
@ -21,11 +21,15 @@ import com.velocitypowered.api.proxy.Player;
import com.velocitypowered.api.proxy.ServerConnection; import com.velocitypowered.api.proxy.ServerConnection;
import com.velocitypowered.api.proxy.server.RegisteredServer; import com.velocitypowered.api.proxy.server.RegisteredServer;
import net.kyori.adventure.text.Component; 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.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver; import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.title.Title; import net.kyori.adventure.title.Title;
import java.util.*; import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
public class ProxyPlayerListener { public class ProxyPlayerListener {
@ -35,15 +39,18 @@ public class ProxyPlayerListener {
Player player = event.getPlayer(); Player player = event.getPlayer();
UUID uuid = player.getUniqueId(); UUID uuid = player.getUniqueId();
Party party = PartyManager.getParty(event.getPlayer().getUniqueId()); Party party = PartyManager.getParty(event.getPlayer().getUniqueId());
if (party == null) return; if (party == null) {
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
if (chatUser == null)
return; return;
}
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
if (chatUser == null) {
return;
}
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party, VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.PARTY_MEMBER_LOGGED_ON, Utility.parseMiniMessage(Config.PARTY_MEMBER_LOGGED_ON,
Placeholder.component("player", chatUser.getDisplayName()) Placeholder.component("player", chatUser.getDisplayName())
), ).asComponent(),
chatUser.getIgnoredPlayers()); chatUser.getIgnoredPlayers());
// TODO setup ChatUser on Proxy // TODO setup ChatUser on Proxy
//VelocityChat.getPlugin().getChatHandler().addPlayer(new ChatPlayer(event.getPlayer().getUniqueId())); //VelocityChat.getPlugin().getChatHandler().addPlayer(new ChatPlayer(event.getPlayer().getUniqueId()));
@ -57,28 +64,32 @@ public class ProxyPlayerListener {
if (previousServer != null) { if (previousServer != null) {
ActiveVoteToMute.removePotentialVoter(player, previousServer); ActiveVoteToMute.removePotentialVoter(player, previousServer);
Optional<ServerConnection> currentServer = player.getCurrentServer(); Optional<ServerConnection> currentServer = player.getCurrentServer();
if (currentServer.isEmpty()) if (currentServer.isEmpty()) {
return; return;
}
ActiveVoteToMute.addPotentialVoter(player, currentServer.get()); ActiveVoteToMute.addPotentialVoter(player, currentServer.get());
return; return;
} }
Optional<ServerConnection> currentServer = player.getCurrentServer(); Optional<ServerConnection> currentServer = player.getCurrentServer();
if (currentServer.isEmpty()) if (currentServer.isEmpty()) {
return; return;
}
ActiveVoteToMute.addPotentialVoter(player, currentServer.get()); ActiveVoteToMute.addPotentialVoter(player, currentServer.get());
ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId()); ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId());
List<Mail> unReadMail = chatUser.getUnReadMail(); List<Mail> unReadMail = chatUser.getUnReadMail();
if (unReadMail.isEmpty()) if (unReadMail.isEmpty()) {
return; return;
}
VelocityChat plugin = VelocityChat.getPlugin(); VelocityChat plugin = VelocityChat.getPlugin();
plugin.getProxy().getScheduler().buildTask(plugin, () -> { plugin.getProxy().getScheduler().buildTask(plugin, () -> {
if (!player.isActive()) if (!player.isActive()) {
return; return;
}
Component message = Utility.parseMiniMessage(Config.mailUnread, ComponentLike message = Utility.parseMiniMessage(Config.mailUnread,
Placeholder.unparsed("amount", String.valueOf(unReadMail.size()))); Placeholder.unparsed("amount", String.valueOf(unReadMail.size())));
player.sendMessage(message); player.sendMessage(message);
player.showTitle(Title.title(message, Component.empty())); player.showTitle(Title.title(message.asComponent(), Component.empty()));
}).delay(Config.mailDisplayDelay * 50L, TimeUnit.MILLISECONDS).schedule(); }).delay(Config.mailDisplayDelay * 50L, TimeUnit.MILLISECONDS).schedule();
} }
@ -88,24 +99,25 @@ public class ProxyPlayerListener {
ActiveVoteToMute.removePotentialVoter(event.getPlayer(), null); ActiveVoteToMute.removePotentialVoter(event.getPlayer(), null);
UUID uuid = event.getPlayer().getUniqueId(); UUID uuid = event.getPlayer().getUniqueId();
Party party = PartyManager.getParty(event.getPlayer().getUniqueId()); Party party = PartyManager.getParty(event.getPlayer().getUniqueId());
if (party == null) return; if (party == null) {
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
if (chatUser == null)
return; return;
}
ChatUser chatUser = ChatUserManager.getChatUser(uuid);
if (chatUser == null) {
return;
}
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party, VelocityChat.getPlugin().getChatHandler().sendPartyMessage(party,
Utility.parseMiniMessage(Config.PARTY_MEMBER_LOGGED_OFF, Utility.parseMiniMessage(Config.PARTY_MEMBER_LOGGED_OFF,
Placeholder.component("player", chatUser.getDisplayName()) Placeholder.component("player", chatUser.getDisplayName())
), ).asComponent(),
chatUser.getIgnoredPlayers()); chatUser.getIgnoredPlayers());
// TODO setup ChatUser on Proxy // TODO setup ChatUser on Proxy
//VelocityChat.getPlugin().getChatHandler().removePlayer(event.getPlayer().getUniqueId()); //VelocityChat.getPlugin().getChatHandler().removePlayer(event.getPlayer().getUniqueId());
} }
private static final HashSet<UUID> silentJoin = new HashSet<>(); private static final HashSet<UUID> silentJoin = new HashSet<>();
public static void addSilentJoin(UUID uuid) public static void addSilentJoin(UUID uuid) {
{
silentJoin.add(uuid); silentJoin.add(uuid);
} }
@ -122,11 +134,11 @@ public class ProxyPlayerListener {
Placeholder.parsed("player", player.getUsername()), Placeholder.parsed("player", player.getUsername()),
Placeholder.parsed("from_server", previousServer.getServerInfo().getName()), Placeholder.parsed("from_server", previousServer.getServerInfo().getName()),
Placeholder.parsed("to_server", event.getServer().getServerInfo().getName()) Placeholder.parsed("to_server", event.getServer().getServerInfo().getName())
); );
if (silentJoin.remove(uuid)) { if (silentJoin.remove(uuid)) {
Component message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED_FROM, ComponentLike message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED_FROM,
placeholders); placeholders);
event.getServer().getPlayersConnected().stream() event.getServer().getPlayersConnected().stream()
.filter(player1 -> player1.hasPermission("command.chat.silent-join-notify")) .filter(player1 -> player1.hasPermission("command.chat.silent-join-notify"))
.forEach(player1 -> player1.sendMessage(message)); .forEach(player1 -> player1.sendMessage(message));
@ -134,17 +146,17 @@ public class ProxyPlayerListener {
} }
ServerWrapper wrapper = serverHandler.getWrapper(previousServer.getServerInfo().getName()); ServerWrapper wrapper = serverHandler.getWrapper(previousServer.getServerInfo().getName());
if(wrapper != null) { if (wrapper != null) {
wrapper.sendJoinLeaveMessage(uuid, Utility.parseMiniMessage(Config.SERVERSWTICHMESSAGETO, placeholders)); wrapper.sendJoinLeaveMessage(uuid, Utility.parseMiniMessage(Config.SERVERSWTICHMESSAGETO, placeholders));
} }
wrapper = serverHandler.getWrapper(event.getServer().getServerInfo().getName()); wrapper = serverHandler.getWrapper(event.getServer().getServerInfo().getName());
if(wrapper != null) { if (wrapper != null) {
wrapper.sendJoinLeaveMessage(uuid, Utility.parseMiniMessage(Config.SERVERSWTICHMESSAGEFROM, placeholders)); wrapper.sendJoinLeaveMessage(uuid, Utility.parseMiniMessage(Config.SERVERSWTICHMESSAGEFROM, placeholders));
} }
} else { } else {
if (silentJoin.remove(uuid)) { if (silentJoin.remove(uuid)) {
Component message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED, ComponentLike message = Utility.parseMiniMessage(Config.SILENT_JOIN_JOINED,
Placeholder.unparsed("player", player.getUsername())); Placeholder.unparsed("player", player.getUsername()));
event.getServer().getPlayersConnected().stream() event.getServer().getPlayersConnected().stream()
.filter(player1 -> player1.hasPermission("command.chat.silent-join-notify")) .filter(player1 -> player1.hasPermission("command.chat.silent-join-notify"))
.forEach(player1 -> player1.sendMessage(message)); .forEach(player1 -> player1.sendMessage(message));
@ -152,7 +164,7 @@ public class ProxyPlayerListener {
} }
ServerWrapper wrapper = serverHandler.getWrapper(event.getServer().getServerInfo().getName()); ServerWrapper wrapper = serverHandler.getWrapper(event.getServer().getServerInfo().getName());
if(wrapper != null) { if (wrapper != null) {
wrapper.sendJoinLeaveMessage(uuid, Utility.parseMiniMessage(Config.SERVERJOINMESSAGE, Placeholder.unparsed("player", player.getUsername()))); wrapper.sendJoinLeaveMessage(uuid, Utility.parseMiniMessage(Config.SERVERJOINMESSAGE, Placeholder.unparsed("player", player.getUsername())));
} }
} }
@ -165,11 +177,11 @@ public class ProxyPlayerListener {
RegisteredServer registeredServer = event.getPlayer().getCurrentServer().get().getServer(); RegisteredServer registeredServer = event.getPlayer().getCurrentServer().get().getServer();
ServerWrapper wrapper = serverHandler.getWrapper(registeredServer.getServerInfo().getName()); ServerWrapper wrapper = serverHandler.getWrapper(registeredServer.getServerInfo().getName());
if(wrapper != null) { if (wrapper != null) {
wrapper.sendJoinLeaveMessage(event.getPlayer().getUniqueId(), Utility.parseMiniMessage(Config.SERVERLEAVEMESSAGE, wrapper.sendJoinLeaveMessage(event.getPlayer().getUniqueId(), Utility.parseMiniMessage(Config.SERVERLEAVEMESSAGE,
Placeholder.unparsed("player", event.getPlayer().getUsername()), Placeholder.unparsed("player", event.getPlayer().getUsername()),
Placeholder.unparsed("from_server", registeredServer.getServerInfo().getName()) Placeholder.unparsed("from_server", registeredServer.getServerInfo().getName())
)); ));
} }
} }
} }