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

Merge pull request #2 from Altitude-Devs/Changes

Browse Source 
Make use of the new 1.19 chat features + other updates
This commit is contained in:
destro174 2022-10-01 20:53:49 +02:00 committed by GitHub
parent 643fb5a633 5ec1f08fe1
commit aab68e5e7f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 2005 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -79,7 +79,7 @@ public final class Config {
method.setAccessible(true);
method.invoke(instance);
} catch (InvocationTargetException | IllegalAccessException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}
}
@ -87,7 +87,7 @@ public final class Config {
try {
configLoader.save(config);
} catch (IOException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}
@ -95,7 +95,7 @@ public final class Config {
try {
configLoader.save(config);
} catch (IOException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}
@ -108,6 +108,7 @@ public final class Config {
try {
config.node(splitPath(path)).set(def);
} catch (SerializationException e) {
e.printStackTrace();
}
}
}
@ -117,6 +118,7 @@ public final class Config {
if(config.node(splitPath(path)).virtual())
config.node(splitPath(path)).set(io.leangen.geantyref.TypeToken.get(String.class), def);
} catch(SerializationException ex) {
ex.printStackTrace();
}
}
@ -150,6 +152,7 @@ public final class Config {
set(path, def);
return config.node(splitPath(path)).getList(TypeToken.get(String.class));
} catch(SerializationException ex) {
ex.printStackTrace();
}
return new ArrayList<>();
}
@ -169,6 +172,7 @@ public final class Config {
public static String MINIMIUMSTAFFRANK = "trainee";
public static String CONSOLENAME = "Console";
public static UUID CONSOLEUUID = UUID.randomUUID();
public static int EMOTELIMIT = 3;
private static void settings() {
PREFIXGROUPS = getList("settings.prefix-groups",
Lists.newArrayList("discord", "socialmedia", "eventteam", "eventleader", "youtube", "twitch", "developer"));
@ -179,6 +183,7 @@ public final class Config {
CONSOLENAME = getString("settings.console-name", CONSOLENAME);
CONSOLEUUID = UUID.fromString(getString("settings.console-uuid", CONSOLEUUID.toString()));
MINIMIUMSTAFFRANK = getString("settings.minimum-staff-rank", MINIMIUMSTAFFRANK);
EMOTELIMIT = getInt("settings.emote-limit", EMOTELIMIT);
}
public static List<String> MESSAGECOMMANDALIASES = new ArrayList<>();
@ -466,4 +471,73 @@ public final class Config {
private static void loadMessages() {
HELP_REPORT = getString("settings.mail.mail-sent", HELP_REPORT);
}
public static String EMOTELIST_HEADER = "<bold>Available Chat Emotes</bold><newline>";
public static String EMOTELIST_ITEM = "<insert:\"<regex>\"><gold><regex></gold> : <emote></insert><newline>";
public static String EMOTELIST_FOOTER = "<green>----<< <gray>Prev</gray> <page> <gray>/</gray> <pages> <gray>Next</gray> >>----";
private static void emoteListCommand() {
EMOTELIST_HEADER = getString("commands.emotelist.header", EMOTELIST_HEADER);
EMOTELIST_ITEM = getString("commands.emotelist.item", EMOTELIST_ITEM);
EMOTELIST_FOOTER = getString("commands.emotelist.footer", EMOTELIST_FOOTER);
}
// nicknames TODO minimessage for colors and placeholders
public static String NICK_CHANGED = "&eYour nickname was changed to %nickname%&e.";
public static String NICK_NOT_CHANGED = "&eYour nickname request was denied.";
public static String NICK_RESET = "&eNickname changed back to normal.";
public static String NICK_CHANGED_OTHERS = "&6%targetplayer%&e's nickname was changed to %nickname%&e.";
public static String NICK_TARGET_NICK_CHANGE = "&eYour nickname was changed to %nickname% &eby %sendernick%&e";
public static String NICK_RESET_OTHERS = "&6%player%&6's &enickname was reset back to normal.";
public static String NICK_INVALID_CHARACTERS = "&eYou can only use letters and numbers in nicknames.";
public static String NICK_INVALID_LENGTH = "&eNicknames need to be between 3 to 16 characters long.";
public static String NICK_PLAYER_NOT_ONLINE = "&cThat player is not online.";
public static String NICK_BLOCKED_COLOR_CODES = "&eYou have blocked color codes in that nickname.";
public static String NICK_USER_NOT_FOUND = "&cFailed to set nickname from player, try again from a server this player has been on before.";
public static String NICK_ACCEPTED = "&aYou accepted %targetPlayer%&a's nickname. They are now called %newNick%&a.";
public static String NICK_DENIED = "&aYou denied %targetPlayer%&a's nickname. They are still called %oldNick%&a.";
public static String NICK_ALREADY_HANDLED = "&c%targetPlayer%&c's nickname was already accepted or denied.";
public static String NICK_NO_LUCKPERMS = "&cDue to an issue with LuckPerms /nick try won't work at the moment.";
public static String NICK_TOO_SOON = "&cPlease wait %time%&c until requesting a new nickname";
public static String NICK_REQUEST_PLACED = "&aReplaced your previous request %oldRequestedNick%&a with %newRequestedNick%&a.";
public static String NICK_REQUEST_NEW = "&aNew nickname request by %player%&a!";
public static String NICK_TRYOUT = "&f%prefix&f %nick%&7: &fHi, this is what my new nickname could look like!";
public static String NICK_REQUESTED = "&aYour requested to be nicknamed %nick%&a has been received. Staff will accept or deny this request asap!";
public static String NICK_REVIEW_WAITING = "&aThere are %amount% nicknames waiting for review!";
public static String NICK_TAKEN = "&cSomeone else already has this nickname, or has this name as their username.";
public static String NICK_REQUESTS_ON_LOGIN = "&aCurrent nick requests: %amount%";
public static long NICK_WAIT_TIME = 86400000;
public static List<String> NICK_ITEM_LORE = new ArrayList<>();
public static List<String> NICK_BLOCKED_COLOR_CODESLIST = new ArrayList<>();
public static List<String> NICK_ALLOWED_COLOR_CODESLIST = new ArrayList<>();
public static String NICK_CURRENT = "<gold>Current nickname: <nickname><white>(<insert:\"<currentnickname>\"><currentnickname></insert>)";
private static void nicknameSettings() {
NICK_CHANGED = getString("nicknames.messages.nick-changed", NICK_CHANGED);
NICK_NOT_CHANGED = getString("nicknames.messages.nick-not-changed", NICK_NOT_CHANGED);
NICK_RESET = getString("nicknames.messages.nick-reset", NICK_RESET);
NICK_CHANGED_OTHERS = getString("nicknames.messages.nick-changed-others", NICK_CHANGED_OTHERS);
NICK_TARGET_NICK_CHANGE = getString("nicknames.messages.nick-target-nick-change", NICK_TARGET_NICK_CHANGE);
NICK_RESET_OTHERS = getString("nicknames.messages.nick-reset-others", NICK_RESET_OTHERS);
NICK_INVALID_CHARACTERS = getString("nicknames.messages.nick-invalid-characters", NICK_INVALID_CHARACTERS);
NICK_INVALID_LENGTH = getString("nicknames.messages.nick-invalid-length", NICK_INVALID_LENGTH);
NICK_PLAYER_NOT_ONLINE = getString("nicknames.messages.nick-player-not-online", NICK_PLAYER_NOT_ONLINE);
NICK_BLOCKED_COLOR_CODES = getString("nicknames.messages.nick-blocked-color-codes", NICK_BLOCKED_COLOR_CODES);
NICK_USER_NOT_FOUND = getString("nicknames.messages.nick-user-not-found", NICK_USER_NOT_FOUND);
NICK_ACCEPTED = getString("nicknames.messages.nick-accepted", NICK_ACCEPTED);
NICK_DENIED = getString("nicknames.messages.nick-denied", NICK_DENIED);
NICK_ALREADY_HANDLED = getString("nicknames.messages.nick-already-handled", NICK_ALREADY_HANDLED);
NICK_NO_LUCKPERMS = getString("nicknames.messages.nick-no-luckperms", NICK_NO_LUCKPERMS);
NICK_TOO_SOON = getString("nicknames.messages.nick-too-soon", NICK_TOO_SOON);
NICK_REQUEST_PLACED = getString("nicknames.messages.nick-request-placed", NICK_REQUEST_PLACED);
NICK_REQUEST_NEW = getString("nicknames.messages.nick-request-new", NICK_REQUEST_NEW);
NICK_TRYOUT = getString("nicknames.messages.nick-tryout", NICK_TRYOUT);
NICK_REQUESTED = getString("nicknames.messages.nick-requested", NICK_REQUESTED);
NICK_REVIEW_WAITING = getString("nicknames.messages.nick-review-waiting", NICK_REVIEW_WAITING);
NICK_TAKEN = getString("nicknames.messages.nick-taken", NICK_TAKEN);
NICK_REQUESTS_ON_LOGIN = getString("nicknames.messages.nick-reauests-on-login", NICK_REQUESTS_ON_LOGIN);
NICK_WAIT_TIME = getLong("nicknames.wait-time", NICK_WAIT_TIME);
NICK_ITEM_LORE = getList("nicknames.item-lore", List.of("&bNew nick: %newNick%", "&bOld nick: %oldNick%", "&bLast changed: %lastChanged%", "&aLeft click to Accept &d| &cRight click to Deny"));
NICK_BLOCKED_COLOR_CODESLIST = getList("nicknames.blocked-color-codes", List.of("&k", "&l", "&n", "&m", "&o"));
NICK_ALLOWED_COLOR_CODESLIST = getList("nicknames.allowed-color-codes", List.of("&0", "&1", "&2", "&3", "&4", "&5", "&6", "&7", "&8", "&9", "&a", "&b", "&c", "&d", "&e", "&f", "&r"));
NICK_CURRENT = getString("nicknames.messages.nick-current", NICK_CURRENT);
}
}

8
api/src/main/java/com/alttd/chat/config/PrefixConfig.java
View File

@ -80,7 +80,7 @@ public final class PrefixConfig {
method.setAccessible(true);
method.invoke(instance);
} catch (InvocationTargetException | IllegalAccessException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}
}
@ -88,7 +88,7 @@ public final class PrefixConfig {
try {
configLoader.save(config);
} catch (IOException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}
@ -96,7 +96,7 @@ public final class PrefixConfig {
try {
configLoader.save(config);
} catch (IOException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}
@ -109,6 +109,7 @@ public final class PrefixConfig {
try {
config.node(splitPath(path)).set(def);
} catch (SerializationException e) {
e.printStackTrace();
}
}
}
@ -118,6 +119,7 @@ public final class PrefixConfig {
if(config.node(splitPath(path)).virtual())
config.node(splitPath(path)).set(io.leangen.geantyref.TypeToken.get(String.class), def);
} catch(SerializationException ex) {
ex.printStackTrace();
}
}

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

@ -3,14 +3,12 @@ package com.alttd.chat.config;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.objects.ChatFilter;
import com.alttd.chat.util.ALogger;
import com.google.common.base.Throwables;
import io.leangen.geantyref.TypeToken;
import org.spongepowered.configurate.ConfigurationNode;
import org.spongepowered.configurate.ConfigurationOptions;
import org.spongepowered.configurate.serialize.SerializationException;
import org.spongepowered.configurate.yaml.NodeStyle;
import org.spongepowered.configurate.yaml.YamlConfigurationLoader;
import org.yaml.snakeyaml.DumperOptions;
import java.io.File;
import java.io.IOException;
@ -78,7 +76,7 @@ public final class RegexConfig {
method.setAccessible(true);
method.invoke(instance);
} catch (InvocationTargetException | IllegalAccessException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}
}
@ -86,7 +84,7 @@ public final class RegexConfig {
try {
configLoader.save(config);
} catch (IOException ex) {
throw Throwables.propagate(ex.getCause());
ex.printStackTrace();
}
}

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

@ -1,18 +1,13 @@
package com.alttd.chat.database;
import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Mail;
import com.alttd.chat.objects.Party;
import com.alttd.chat.objects.PartyUser;
import com.alttd.chat.objects.*;
import com.alttd.chat.objects.channels.Channel;
import com.alttd.chat.util.ALogger;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.UUID;
import java.util.*;
import java.util.Date;
public class Queries {
@ -24,7 +19,8 @@ public class Queries {
tables.add("CREATE TABLE IF NOT EXISTS parties (`id` INT NOT NULL AUTO_INCREMENT, `owner_uuid` VARCHAR(36) NOT NULL, `party_name` VARCHAR(36) NOT NULL, `password` VARCHAR(36), PRIMARY KEY (`id`))");
tables.add("CREATE TABLE IF NOT EXISTS chat_users (`uuid` VARCHAR(36) NOT NULL, `party_id` INT NOT NULL, `toggled_channel` VARCHAR(36) NULL DEFAULT NULL, PRIMARY KEY (`uuid`))");
tables.add("CREATE TABLE IF NOT EXISTS mails (`id` INT NOT NULL AUTO_INCREMENT, `uuid` VARCHAR(36) NOT NULL, `sender` VARCHAR(36) NOT NULL, `message` VARCHAR(256) NOT NULL, `sendtime` BIGINT default 0, `readtime` BIGINT default 0, PRIMARY KEY (`id`))");
createNicknamesTable();
createRequestedNicknamesTable();
try {
Connection connection = DatabaseConnection.getConnection();
@ -39,6 +35,51 @@ public class Queries {
//-----------------------------------------
//Nicknames
private static void createNicknamesTable() {
try {
String nicknamesTableQuery = "CREATE TABLE IF NOT EXISTS nicknames("
+ "uuid VARCHAR(48) NOT NULL,"
+ "PRIMARY KEY (uuid))";
DatabaseConnection.getConnection().prepareStatement(nicknamesTableQuery).executeUpdate();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
List<String> columns = new ArrayList<>();
columns.add("ALTER TABLE nicknames ADD nickname VARCHAR(192)");
columns.add("ALTER TABLE nicknames ADD date_changed BIGINT default 0");
for (String string : columns) {
try {
DatabaseConnection.getConnection().prepareStatement(string).executeUpdate();
} catch (Throwable ignored) {
}
}
}
private static void createRequestedNicknamesTable() {
try {
String requestedNicknamesTableQuery = "CREATE TABLE IF NOT EXISTS requested_nicknames("
+ "uuid VARCHAR(48) NOT NULL,"
+ "PRIMARY KEY (uuid))";
DatabaseConnection.getConnection().prepareStatement(requestedNicknamesTableQuery).executeUpdate();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
List<String> columns = new ArrayList<>();
columns.add("ALTER TABLE requested_nicknames ADD nickname VARCHAR(192)");
columns.add("ALTER TABLE requested_nicknames ADD date_requested BIGINT default 0");
for (String string : columns) {
try {
DatabaseConnection.getConnection().prepareStatement(string).executeUpdate();
} catch (Throwable ignored) {
}
}
}
public static String getNickname(UUID uuid) {
// View has been created.
@ -564,4 +605,172 @@ public class Queries {
e.printStackTrace();
}
}
// Nicknames
public static void setNicknameInDatabase(final UUID uuid, final String nickName) {
final String sql = "INSERT INTO nicknames (uuid, nickname, date_changed) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE nickname = ?";
try (final PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(sql)) {
statement.setString(1, uuid.toString());
statement.setString(2, nickName);
statement.setLong(3, new java.util.Date().getTime());
statement.setString(4, nickName);
statement.execute();
}
catch (SQLException e) {
e.printStackTrace();
}
}
public static void removePlayerFromDataBase(final UUID uuid) throws SQLException {
final PreparedStatement insert = DatabaseConnection.getConnection().prepareStatement("DELETE FROM nicknames WHERE uuid = ?");
insert.setString(1, uuid.toString());
insert.executeUpdate();
insert.close();
}
public static ArrayList<Nick> getNicknamesList() {
ArrayList<Nick> nickList = new ArrayList<>();
String queryNicknames = "SELECT uuid, nickname, date_changed FROM nicknames ";
String queryRequests = "SELECT `requested_nicknames`.`nickname` AS new_nick, `requested_nicknames`.`date_requested`, " +
"`nicknames`.`nickname` AS old_nick, `nicknames`.`date_changed`, `requested_nicknames`.`uuid` " +
"FROM `requested_nicknames`" +
"LEFT JOIN `nicknames` ON `requested_nicknames`.`uuid` = `nicknames`.`uuid` ";
try {
ResultSet resultSetNicknames = getStringResult(queryNicknames);
while (resultSetNicknames.next()){
nickList.add(new Nick(
UUID.fromString(resultSetNicknames.getString("uuid")),
resultSetNicknames.getString("nickname"),
resultSetNicknames.getLong("date_changed")));
}
ResultSet resultSetRequests = getStringResult(queryRequests);
while (resultSetRequests.next()){
nickList.add(new Nick(
UUID.fromString(resultSetRequests.getString("uuid")),
resultSetRequests.getString("old_nick"),
resultSetRequests.getLong("date_changed"),
resultSetRequests.getString("new_nick"),
resultSetRequests.getLong("date_requested")));
}
} catch (SQLException e) {
ALogger.warn("Failed to get nicknames list\n" + Arrays.toString(e.getStackTrace())
.replace(",", "\n"));
}
return nickList;
}
public static Nick getNick(UUID uniqueId) {
String getNick = "SELECT nickname, date_changed, uuid FROM nicknames WHERE uuid = ?";
String getRequest = "SELECT nickname, date_requested, uuid FROM requested_nicknames WHERE uuid = ?";
try {
ResultSet resultSetNick = getStringResult(getNick, uniqueId.toString());
ResultSet resultSetRequest = getStringResult(getRequest, uniqueId.toString());
String uuid = null;
String currentNick = null;
long dateChanged = 0;
String requestedNick = null;
long dateRequested = 0;
if (resultSetNick.next()) {
uuid = resultSetNick.getString("uuid");
currentNick = resultSetNick.getString("nickname");
dateChanged = resultSetNick.getLong("date_changed");
}
if (resultSetRequest.next()) {
uuid = resultSetRequest.getString("uuid");
requestedNick = resultSetRequest.getString("nickname");
dateRequested = resultSetRequest.getLong("date_requested");
}
if (uuid != null) {
return new Nick(UUID.fromString(uuid), currentNick, dateChanged, requestedNick, dateRequested);
}
} catch (SQLException e){
ALogger.warn("Failed to get nicknames for "
+ uniqueId.toString() + "\n" + Arrays.toString(e.getStackTrace())
.replace(",", "\n"));
}
return null;
}
public static void denyNewNickname(UUID uniqueId) {
String query = "DELETE FROM requested_nicknames WHERE uuid = ?";
try {
PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(query);
statement.setString(1, uniqueId.toString());
statement.execute();
} catch (SQLException e) {
ALogger.warn("Failed to delete requested nickname for "
+ uniqueId.toString() + "\n" + Arrays.toString(e.getStackTrace())
.replace(",", "\n"));
}
}
public static void acceptNewNickname(UUID uniqueId, String newNick){
String delete = "DELETE FROM requested_nicknames WHERE uuid = ?";
String update = "INSERT INTO nicknames (uuid, nickname, date_changed) VALUES (?, ?, ?) " +
"ON DUPLICATE KEY UPDATE nickname = ?, date_changed = ?";
long time = new java.util.Date().getTime();
try {
PreparedStatement deleteStatement = DatabaseConnection.getConnection().prepareStatement(delete);
deleteStatement.setString(1, uniqueId.toString());
deleteStatement.execute();
PreparedStatement updateStatement = DatabaseConnection.getConnection().prepareStatement(update);
updateStatement.setString(1, uniqueId.toString());
updateStatement.setString(2, newNick);
updateStatement.setLong(3, time);
updateStatement.setString(4, newNick);
updateStatement.setLong(5, time);
updateStatement.execute();
} catch (SQLException e) {
ALogger.warn("Failed to accept requested nickname for "
+ uniqueId.toString() + "\n" + Arrays.toString(e.getStackTrace())
.replace(",", "\n"));
}
}
public static void newNicknameRequest(UUID uniqueId, String nickName) {
String requestQuery = "INSERT INTO requested_nicknames (uuid, nickname, date_requested) VALUES (?, ?, ?) " +
"ON DUPLICATE KEY UPDATE nickname = ?, date_requested = ?";
String nickQuery = "INSERT INTO nicknames (uuid, nickname, date_changed) VALUES (?, ?, 0) " +
"ON DUPLICATE KEY UPDATE uuid = uuid";
long time = new Date().getTime();
try {
PreparedStatement requestPreparedStatement = DatabaseConnection.getConnection().prepareStatement(requestQuery);
requestPreparedStatement.setString(1, uniqueId.toString());
requestPreparedStatement.setString(2, nickName);
requestPreparedStatement.setLong(3, time);
requestPreparedStatement.setString(4, nickName);
requestPreparedStatement.setLong(5, time);
requestPreparedStatement.execute();
PreparedStatement nickPreparedStatement = DatabaseConnection.getConnection().prepareStatement(nickQuery);
nickPreparedStatement.setString(1, uniqueId.toString());
nickPreparedStatement.setString(2, null);
nickPreparedStatement.execute();
} catch (SQLException e) {
ALogger.warn("Failed to store requested nickname for "
+ uniqueId.toString() + "\n" + Arrays.toString(e.getStackTrace())
.replace(",", "\n"));
}
}
private static ResultSet getStringResult(final String query, final String... parameters) throws SQLException {
final PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(query);
for (int i = 1; i < parameters.length + 1; ++i) {
statement.setString(i, parameters[i - 1]);
}
return statement.executeQuery();
}
}

56
api/src/main/java/com/alttd/chat/events/NickEvent.java Normal file
View File

@ -0,0 +1,56 @@
package com.alttd.chat.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.jetbrains.annotations.NotNull;
public class NickEvent extends Event{
String senderName;
String targetName;
String nickName;
NickEventType nickEventType;
public NickEvent(String senderName, String targetName, String nickName, NickEventType nickEventType) {
this.senderName = senderName;
this.targetName = targetName;
this.nickName = nickName;
this.nickEventType = nickEventType;
}
public String getSenderName() {
return this.senderName;
}
public String getTargetName() {
return this.targetName;
}
public String getNickName() {
return this.nickName;
}
public NickEventType getNickEventType() {
return this.nickEventType;
}
private static final HandlerList HANDLERS = new HandlerList();
public static HandlerList getHandlerList() {
return HANDLERS;
}
@NotNull
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public enum NickEventType {
ACCEPTED,
DENIED,
SET,
RESET
}
}

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

@ -3,6 +3,7 @@ package com.alttd.chat.managers;
import com.alttd.chat.ChatAPI;
import com.alttd.chat.config.RegexConfig;
import com.alttd.chat.objects.ChatFilter;
import com.alttd.chat.objects.FilterType;
import com.alttd.chat.objects.ModifiableString;
import com.alttd.chat.util.ALogger;
import net.luckperms.api.cacheddata.CachedPermissionData;
@ -17,11 +18,24 @@ public class RegexManager {
private static List<ChatFilter> chatFilters;
private static final Pattern pattern = Pattern.compile("(.)\\1{4,}");
private static final List<ChatFilter> emotes = new ArrayList<>();
public static final List<String> emotesList = new ArrayList<>();
public static void initialize() {
chatFilters = new ArrayList<>();
RegexConfig.init();
loadEmotes();
}
private static void loadEmotes() {
emotes.clear();
for(ChatFilter chatFilter : chatFilters) {
if (chatFilter.getType() != FilterType.EMOTE) return;
emotes.add(chatFilter);
emotesList.add(chatFilter.getRegex());
}
}
public static void addFilter(ChatFilter filter) {
@ -65,4 +79,11 @@ public class RegexManager {
return true;
}
public static List<ChatFilter> getChatFilters() {
return chatFilters;
}
public static List<ChatFilter> getEmoteFilters() {
return emotes;
}
}

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

@ -180,4 +180,8 @@ public class ChatUser {
}
setDisplayName(name);
}
public String getNickNameString() {
return name;
}
}

64
api/src/main/java/com/alttd/chat/objects/EmoteList.java Normal file
View File

@ -0,0 +1,64 @@
package com.alttd.chat.objects;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import org.bukkit.Bukkit;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class EmoteList {
public static final Map<UUID, EmoteList> emoteLists = new HashMap<>();
public static final int pageSize = 7;
// public static int pages = RegexManager.getEmoteFilters().size() / pageSize;// TODO reload this when config is reloaded.
public static EmoteList getEmoteList(UUID uuid) {
synchronized (emoteLists) {
return emoteLists.computeIfAbsent(uuid, k -> new EmoteList());
}
}
private int page;
public Component showEmotePage() {
int startIndex = page * pageSize;
int pages = RegexManager.getEmoteFilters().size() / pageSize;
int endIndex = Math.min(startIndex + pageSize, RegexManager.getEmoteFilters().size());
TagResolver placeholders = TagResolver.resolver(
Placeholder.unparsed("page", String.valueOf(page)),
Placeholder.unparsed("pages", String.valueOf(pages))
);
Component list = Utility.parseMiniMessage(Config.EMOTELIST_HEADER, placeholders);
for (int i = startIndex; i < endIndex; i++) {
ChatFilter emote = RegexManager.getEmoteFilters().get(i);
TagResolver emotes = TagResolver.resolver(
Placeholder.parsed("regex", emote.getRegex()),
Placeholder.parsed("emote", emote.getReplacement())
);
list = list.append(Utility.parseMiniMessage(Config.EMOTELIST_ITEM, emotes));
}
list = list.append(Utility.parseMiniMessage(Config.EMOTELIST_FOOTER, placeholders));
return list;
}
public void setPage(int page) {
this.page = Math.min(page, RegexManager.getEmoteFilters().size() / pageSize);
}
public void nextPage() {
this.page = Math.min(page + 1, RegexManager.getEmoteFilters().size() / pageSize);
}
public void prevPage() {
this.page -= 1;
this.page = Math.max(page - 1, 0);
}
}

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

@ -2,6 +2,7 @@ package com.alttd.chat.objects;
public enum FilterType {
REPLACE("replace"),
EMOTE("emote"),
CHAT("chat"),
REPLACEMATCHER("replacematcher"),
BLOCK("block");

99
api/src/main/java/com/alttd/chat/objects/Nick.java Normal file
View File

@ -0,0 +1,99 @@
package com.alttd.chat.objects;
import com.alttd.chat.util.Utility;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
public class Nick {
private final UUID uuid;
private String currentNick;
private String currentNickNoColor;
private long lastChangedDate;
private String newNick;
private String newNickNoColor;
private long requestedDate;
private boolean hasRequest;
public Nick(UUID uuid, String currentNick, long lastChangedDate) {
this.uuid = uuid;
this.currentNick = currentNick;
currentNickNoColor = currentNick == null ? null : Utility.removeAllColors(currentNick);
this.lastChangedDate = lastChangedDate;
newNick = null;
newNickNoColor = null;
requestedDate = 0;
hasRequest = false;
}
public Nick(UUID uuid, String currentNick, long lastChangedDate, String newNick, long requestedDate) {
this.uuid = uuid;
this.currentNick = currentNick;
currentNickNoColor = currentNick == null ? null : Utility.removeAllColors(currentNick);
this.lastChangedDate = lastChangedDate;
this.newNick = newNick;
newNickNoColor = newNick == null ? null : Utility.removeAllColors(newNick);
this.requestedDate = requestedDate;
hasRequest = newNick != null;
}
public UUID getUuid() {
return uuid;
}
public String getCurrentNickNoColor() {
return currentNickNoColor;
}
public String getCurrentNick() {
return currentNick;
}
public void setCurrentNick(String currentNick) {
this.currentNick = currentNick;
currentNickNoColor = currentNick == null ? null : Utility.removeAllColors(currentNick);
}
public long getLastChangedDate(){
return lastChangedDate;
}
public String getLastChangedDateFormatted() {
return new SimpleDateFormat("yyyy-MM-dd").format(new Date(lastChangedDate));
}
public void setLastChangedDate(long lastChangedDate) {
this.lastChangedDate = lastChangedDate;
}
public String getNewNickNoColor() {
return newNickNoColor;
}
public String getNewNick() {
return newNick;
}
public void setNewNick(String newNick) {
this.newNick = newNick;
newNickNoColor = newNick == null ? null : Utility.removeAllColors(newNick);
hasRequest = newNick != null;
}
public long getRequestedDate(){
return requestedDate;
}
public String getRequestedDateFormatted() {
return new SimpleDateFormat("yyyy-MM-dd").format(new Date(requestedDate));
}
public void setRequestedDate(long requestedDate) {
this.requestedDate = requestedDate;
}
public boolean hasRequest() {
return hasRequest;
}
}

20
api/src/main/java/com/alttd/chat/util/Pair.java Normal file
View File

@ -0,0 +1,20 @@
package com.alttd.chat.util;
public class Pair<X, Y> {
private final X x;
private final Y y;
public Pair(X x, Y y) {
this.x = x;
this.y = y;
}
public X getX() {
return x;
}
public Y getY() {
return y;
}
}

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

@ -3,13 +3,16 @@ package com.alttd.chat.util;
import com.alttd.chat.ChatAPI;
import com.alttd.chat.config.Config;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.TextDecoration;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.luckperms.api.LuckPerms;
import net.luckperms.api.model.group.Group;
import net.luckperms.api.model.user.User;
import net.luckperms.api.node.Node;
import org.bukkit.permissions.Permission;
import java.util.*;
import java.util.regex.Matcher;
@ -18,6 +21,7 @@ import java.util.stream.Collectors;
public class Utility {
private static final List<String> EMPTY_LIST = new ArrayList<>();
static final Pattern DEFAULT_URL_PATTERN = Pattern.compile("(?:(https?)://)?([-\\w_.]+\\.\\w{2,})(/\\S*)?");
private static MiniMessage miniMessage = null;
@ -44,6 +48,38 @@ public class Utility {
colors.put("&e", "<yellow>");
colors.put("&f", "<white>");
}
public static HashMap<String, Pair<TagResolver, List<String>>> formattingPerms = new HashMap<>();
static {
formattingPerms.put("chat.format.color",
new Pair<>(StandardTags.color(), colors.values().stream().toList()));
formattingPerms.put("chat.format.bold",
new Pair<>(StandardTags.decorations(TextDecoration.BOLD), List.of("<bold>", "<b>")));
formattingPerms.put("chat.format.italic",
new Pair<>(StandardTags.decorations(TextDecoration.ITALIC), List.of("<italic>", "<i>")));
formattingPerms.put("chat.format.underlined",
new Pair<>(StandardTags.decorations(TextDecoration.UNDERLINED), List.of("<underlined>", "<u>")));
formattingPerms.put("chat.format.strikethrough",
new Pair<>(StandardTags.decorations(TextDecoration.STRIKETHROUGH), List.of("<strikethrough>", "<st>")));
formattingPerms.put("chat.format.obfuscated",
new Pair<>(StandardTags.decorations(TextDecoration.OBFUSCATED), List.of("<obfuscated>", "<obf>")));
formattingPerms.put("chat.format.gradient",
new Pair<>(StandardTags.gradient(), EMPTY_LIST));
formattingPerms.put("chat.format.font",
new Pair<>(StandardTags.font(), EMPTY_LIST));
formattingPerms.put("chat.format.rainbow",
new Pair<>(StandardTags.rainbow(), List.of("<rainbow>")));
formattingPerms.put("chat.format.hover",
new Pair<>(StandardTags.hoverEvent(), EMPTY_LIST));
formattingPerms.put("chat.format.click",
new Pair<>(StandardTags.clickEvent(), EMPTY_LIST));
formattingPerms.put("chat.format.transition",
new Pair<>(StandardTags.transition(), EMPTY_LIST));
formattingPerms.put("chat.format.reset",
new Pair<>(StandardTags.reset(), List.of("<reset>", "<r>")));
formattingPerms.put("chat.format.newline",
new Pair<>(StandardTags.newline(), List.of("<newline>")));
}
public static String parseColors(String message) {
if (message == null) return "";
@ -264,4 +300,13 @@ public class Utility {
return miniMessage;
}
public static String removeAllColors(String string) {
for (String colorCodes : colors.keySet()) {
string = string.replace(colorCodes, "");
}
return string.replaceAll("\\{#[A-Fa-f0-9]{6}(<)?(>)?}", "");
}
}

7
build.gradle.kts
View File

@ -5,7 +5,7 @@ plugins {
allprojects {
group = "com.alttd.chat"
version = "1.0.0-SNAPSHOT"
version = "2.0.0-SNAPSHOT"
description = "All in one minecraft chat plugin"
// repositories {
@ -61,7 +61,7 @@ dependencies {
tasks {
shadowJar {
archiveFileName.set("${project.name}-${project.version}.jar")
archiveFileName.set("${project.name}.jar")
minimize() {
exclude { it.moduleName == "galaxy" }
exclude { it.moduleName == "velocity" }
@ -77,4 +77,7 @@ tasks {
dependsOn(shadowJar)
}
jar {
enabled = false
}
}

3
galaxy/build.gradle.kts
View File

@ -12,6 +12,7 @@ dependencies {
compileOnly("com.alttd:Galaxy-API:1.19.2-R0.1-SNAPSHOT") // Galaxy
compileOnly("com.gitlab.ruany:LiteBansAPI:0.3.5") // move to proxy
compileOnly("org.apache.commons:commons-lang3:3.12.0") // needs an alternative, already removed from upstream api and will be removed in server
compileOnly("net.luckperms:api:5.3") // Luckperms
}
tasks {
@ -22,7 +23,7 @@ tasks {
}
build {
setBuildDir("${rootProject.buildDir}")
// setBuildDir("${rootProject.buildDir}")
dependsOn(shadowJar)
}

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

@ -5,9 +5,12 @@ import com.alttd.chat.config.Config;
import com.alttd.chat.config.ServerConfig;
import com.alttd.chat.database.DatabaseConnection;
import com.alttd.chat.handler.ChatHandler;
import com.alttd.chat.listeners.BookListener;
import com.alttd.chat.listeners.ChatListener;
import com.alttd.chat.listeners.PlayerListener;
import com.alttd.chat.listeners.PluginMessage;
import com.alttd.chat.nicknames.Nicknames;
import com.alttd.chat.nicknames.NicknamesEvents;
import com.alttd.chat.objects.channels.Channel;
import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.util.ALogger;
@ -38,7 +41,7 @@ public class ChatPlugin extends JavaPlugin {
chatHandler = new ChatHandler();
DatabaseConnection.initialize();
serverConfig = new ServerConfig(Bukkit.getServerName());
registerListener(new PlayerListener(), new ChatListener());
registerListener(new PlayerListener(), new ChatListener(), new BookListener());
if(serverConfig.GLOBALCHAT) {
registerCommand("globalchat", new GlobalChat());
registerCommand("toggleglobalchat", new ToggleGlobalChat());
@ -53,6 +56,7 @@ public class ChatPlugin extends JavaPlugin {
registerCommand("chatclear", new ChatClear());
// registerCommand("chatparty", new ChatParty());
registerCommand("p", new PartyChat());
registerCommand("emotes", new Emotes());
for (Channel channel : Channel.getChannels()) {
if (!(channel instanceof CustomChannel customChannel)) continue;
this.getServer().getCommandMap().register(channel.getChannelName().toLowerCase(), new ChatChannel(customChannel));
@ -61,6 +65,11 @@ public class ChatPlugin extends JavaPlugin {
messageChannel = Config.MESSAGECHANNEL;
getServer().getMessenger().registerOutgoingPluginChannel(this, messageChannel);
getServer().getMessenger().registerIncomingPluginChannel(this, messageChannel, new PluginMessage());
NicknamesEvents nicknamesEvents = new NicknamesEvents();
getServer().getMessenger().registerIncomingPluginChannel(this, messageChannel, nicknamesEvents);
getServer().getPluginManager().registerEvents(nicknamesEvents, this);
registerCommand("nick", new Nicknames());
}
@Override

33
galaxy/src/main/java/com/alttd/chat/commands/Emotes.java Normal file
View File

@ -0,0 +1,33 @@
package com.alttd.chat.commands;
import com.alttd.chat.objects.EmoteList;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
public class Emotes implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
if(!(sender instanceof Player player)) { // must be a player
return true;
}
EmoteList emoteList = EmoteList.getEmoteList(player.getUniqueId());
if(args.length > 0) {
try {
int page = Integer.parseInt(args[0]);
emoteList.setPage(page);
} catch (NumberFormatException ignored) {
switch (args[0].toLowerCase()) {
case "next" -> emoteList.nextPage();
case "prev", "previous" -> emoteList.prevPage();
default -> {}
}
}
}
player.sendMessage(emoteList.showEmotePage());
return false;
}
}

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

@ -4,6 +4,7 @@ import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.objects.ChatFilter;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.ModifiableString;
import com.alttd.chat.objects.channels.CustomChannel;
@ -14,6 +15,7 @@ import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
@ -48,24 +50,14 @@ public class ChatHandler {
target);
return; // the message was blocked
}
String updatedMessage = modifiableString.string();
if(!player.hasPermission("chat.format")) {
updatedMessage = Utility.stripTokens(updatedMessage);
} else {
updatedMessage = Utility.parseColors(updatedMessage);
}
updatedMessage = Utility.formatText(updatedMessage);
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("message", Utility.parseMiniMessage(updatedMessage)),
Placeholder.component("message", parseMessageContent(player, modifiableString.string())),
Placeholder.component("sendername", player.name()),
Placeholder.parsed("receivername", target)
);
Component component = Utility.parseMiniMessage("<message>", placeholders)
.replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand())).build());
Component component = Utility.parseMiniMessage("<message>", placeholders);
sendPrivateMessage(player, target, "privatemessage", component);
Component spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
@ -88,19 +80,8 @@ public class ChatHandler {
target);
return; // the message was blocked
}
String updatedMessage = modifiableString.string();
if(!player.hasPermission("chat.format")) {
updatedMessage = Utility.stripTokens(updatedMessage);
} else {
updatedMessage = Utility.parseColors(updatedMessage);
}
updatedMessage = Utility.formatText(updatedMessage);
Component messageComponent = Utility.parseMiniMessage(updatedMessage)
.replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]")
.replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand())).build());
Component messageComponent = parseMessageContent(player, modifiableString.string());
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("message", messageComponent),
Placeholder.component("sendername", player.name()),
@ -149,18 +130,10 @@ public class ChatHandler {
return; // the message was blocked
}
String updatedMessage = modifiableString.string();
if(!player.hasPermission("chat.format")) {
updatedMessage = Utility.stripTokens(updatedMessage);
} else {
updatedMessage = Utility.parseColors(updatedMessage);
}
updatedMessage = Utility.formatText(updatedMessage);
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName),
Placeholder.component("prefix", prefix),
Placeholder.component("message", Utility.parseMiniMessage(updatedMessage)),
Placeholder.component("message", parseMessageContent(player, modifiableString.string())),
Placeholder.parsed("server", Bukkit.getServerName())
);
@ -190,21 +163,13 @@ public class ChatHandler {
return; // the message was blocked
}
String updatedMessage = modifiableString.string();
if(!player.hasPermission("chat.format")) {
updatedMessage = Utility.stripTokens(updatedMessage);
}
updatedMessage = Utility.formatText(updatedMessage);
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName),
Placeholder.component("message", Utility.parseMiniMessage(updatedMessage)),
Placeholder.component("message", parseMessageContent(player, modifiableString.string())),
Placeholder.parsed("server", Bukkit.getServerName()),
Placeholder.parsed("channel", channel.getChannelName())
);
Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders)
.replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand())).build());
Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders);
if (channel.isProxy()) {
sendChatChannelMessage(player, channel.getChannelName(), "chatchannel", component);
@ -349,4 +314,34 @@ public class ChatHandler {
}
// end - move these to util
private Component parseMessageContent(Player player, String rawMessage) {
TagResolver.Builder tagResolver = TagResolver.builder();
Utility.formattingPerms.forEach((perm, pair) -> {
if (player.hasPermission(perm)) {
tagResolver.resolver(pair.getX());
}
});
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(rawMessage);
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText(
TextReplacementConfig.builder()
.times(Config.EMOTELIMIT)
.match(chatFilter.getRegex())
.replacement(chatFilter.getReplacement()).build());
}
component = component
.replaceText(
TextReplacementConfig.builder()
.once()
.matchLiteral("[i]")
.replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand()))
.build());
return component;
}
}

61
galaxy/src/main/java/com/alttd/chat/listeners/BookListener.java Executable file
View File

@ -0,0 +1,61 @@
package com.alttd.chat.listeners;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.objects.ChatFilter;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerEditBookEvent;
import org.bukkit.inventory.meta.BookMeta;
import java.util.ArrayList;
import java.util.List;
public class BookListener implements Listener {
private final PlainTextComponentSerializer plainTextComponentSerializer = PlainTextComponentSerializer.plainText();
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onPlayerEditBookEvent(PlayerEditBookEvent event) {
BookMeta bookMeta = event.getNewBookMeta();
List<Component> pages = new ArrayList<>();
for (Component component : bookMeta.pages()) {
Component formatComponent = Component.text("%message%");
Component message = parseMessageContent(event.getPlayer(), plainTextComponentSerializer.serialize(component));
pages.add(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
}
bookMeta.pages(pages);
event.setNewBookMeta(bookMeta);
}
private Component parseMessageContent(Player player, String rawMessage) {
TagResolver.Builder tagResolver = TagResolver.builder();
Utility.formattingPerms.forEach((perm, pair) -> {
if (player.hasPermission(perm)) {
tagResolver.resolver(pair.getX());
}
});
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(rawMessage);
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText(
TextReplacementConfig.builder()
.times(Config.EMOTELIMIT)
.match(chatFilter.getRegex())
.replacement(chatFilter.getReplacement()).build());
}
return component;
}
}

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

@ -5,21 +5,25 @@ import com.alttd.chat.config.Config;
import com.alttd.chat.handler.ChatHandler;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.objects.ChatFilter;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.ModifiableString;
import com.alttd.chat.objects.Toggleable;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.GalaxyUtility;
import com.alttd.chat.util.Utility;
import io.papermc.paper.event.player.AsyncChatCommandDecorateEvent;
import io.papermc.paper.event.player.AsyncChatDecorateEvent;
import io.papermc.paper.event.player.AsyncChatEvent;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.serializer.plain.PlainComponentSerializer;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.jetbrains.annotations.NotNull;
@ -28,6 +32,29 @@ import java.util.stream.Collectors;
public class ChatListener implements Listener {
private final PlainTextComponentSerializer plainTextComponentSerializer = PlainTextComponentSerializer.plainText();
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onChatCommandDecorate(AsyncChatCommandDecorateEvent event) {
if (event.player() == null) return;
Component formatComponent = Component.text("%message%");
Component message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
}
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onChatDecorate(AsyncChatDecorateEvent event) {
if (event.player() == null) return;
Component formatComponent = Component.text("%message%");
Component message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
}
@EventHandler(ignoreCancelled = true)
public void onPlayerChat(AsyncChatEvent event) {
event.setCancelled(true); //Always cancel the event because we do not want to deal with Microsoft's stupid bans
@ -43,7 +70,6 @@ public class ChatListener implements Listener {
}
Player player = event.getPlayer();
// ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
Set<Player> receivers = event.viewers().stream().filter(audience -> audience instanceof Player)
.map(audience -> (Player) audience)
@ -61,40 +87,57 @@ public class ChatListener implements Listener {
"");
return; // the message was blocked
}
message = modifiableString.string();
if(!player.hasPermission("chat.format")) {
message = Utility.stripTokens(message);
} else {
message = Utility.parseColors(message);
}
Component component = Utility.parseMiniMessage(Utility.formatText(message));
component = component.replaceText(
TextReplacementConfig.builder()
.once()
.matchLiteral("[i]")
.replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand()))
.build());
component = render(player, component);
input = render(player, plainTextComponentSerializer.deserialize(modifiableString.string()));
for (Player receiver : receivers) {
receiver.sendMessage(component);
receiver.sendMessage(input);
}
ALogger.info(PlainTextComponentSerializer.plainText().serialize(component));
ALogger.info(PlainTextComponentSerializer.plainText().serialize(input));
}
public @NotNull Component render(@NotNull Player player, @NotNull Component message) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("sender", user.getDisplayName()),
// Placeholder.component("sendername", player.name()),
Placeholder.parsed("sendername", player.getName()),
Placeholder.component("prefix", user.getPrefix()),
Placeholder.component("prefixall", user.getPrefixAll()),
Placeholder.component("staffprefix", user.getStaffPrefix()),
Placeholder.component("message", message)
);
return Utility.parseMiniMessage(Config.CHATFORMAT.replaceAll("<sendername>", player.getName()), placeholders);
return Utility.parseMiniMessage(Config.CHATFORMAT, placeholders);
}
private Component parseMessageContent(Player player, String rawMessage) {
TagResolver.Builder tagResolver = TagResolver.builder();
Utility.formattingPerms.forEach((perm, pair) -> {
if (player.hasPermission(perm)) {
tagResolver.resolver(pair.getX());
}
});
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(rawMessage);
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText(
TextReplacementConfig.builder()
.times(Config.EMOTELIMIT)
.match(chatFilter.getRegex())
.replacement(chatFilter.getReplacement()).build());
}
component = component
.replaceText(
TextReplacementConfig.builder()
.once()
.matchLiteral("[i]")
.replacement(ChatHandler.itemComponent(player.getInventory().getItemInMainHand()))
.build());
return component;
}
}

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

@ -23,7 +23,9 @@ public class PlayerListener implements Listener {
@EventHandler
private void onPlayerLogin(PlayerJoinEvent event) {
UUID uuid = event.getPlayer().getUniqueId();
Player player = event.getPlayer();
GalaxyUtility.addAdditionalChatCompletions(player);
UUID uuid = player.getUniqueId();
Toggleable.disableToggles(uuid);
ChatUser user = ChatUserManager.getChatUser(uuid);
if(user != null) return;

214
galaxy/src/main/java/com/alttd/chat/nicknames/NickUtilities.java Normal file
View File

@ -0,0 +1,214 @@
package com.alttd.chat.nicknames;
import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries;
import com.alttd.chat.objects.Nick;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import java.awt.*;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.UUID;
public class NickUtilities
{
public static String stringRegen;
public static String applyColor(String message) {
ChatColor hexColor1 = null;
ChatColor hexColor2;
StringBuilder stringBuilder = new StringBuilder();
message = ChatColor.translateAlternateColorCodes('&', message);
boolean startsWithColor = false;
boolean lastColorMatters = false;
if (message.matches(".*" + NickUtilities.stringRegen + ".*")) {
String[] split = message.split(NickUtilities.stringRegen);
ArrayList<String> list = new ArrayList<>();
int nextIndex = 0;
if (message.indexOf("}") <= 11) {
startsWithColor = true;
list.add(message.substring(0, message.indexOf("}") + 1));
}
for (String s : split) {
nextIndex += s.length();
int tmp = message.indexOf("}", nextIndex);
if (tmp < message.length() && tmp>=0) {
list.add(message.substring(nextIndex, tmp + 1));
nextIndex = tmp + 1;
}
}
int i;
boolean firstLoop = true;
if (startsWithColor) {
i = -1;
} else {
i = 0;
stringBuilder.append(split[i]);
}
for (String s : list) {
boolean lesser = s.contains("<");
boolean bigger = s.contains(">");
if (bigger && lesser) {
hexColor2 = ChatColor.of(s.substring(1, s.length() - 3));
} else if (bigger || lesser) {
hexColor2 = ChatColor.of(s.substring(1, s.length() - 2));
} else {
hexColor2 = ChatColor.of(s.substring(1, s.length() -1));
}
if (firstLoop) {
lastColorMatters = bigger;
hexColor1 = hexColor2;
firstLoop = false;
i++;
continue;
}
if (lesser && lastColorMatters) {
stringBuilder.append(hexGradient(hexColor1.getColor(), hexColor2.getColor(), split[i]));
} else {
stringBuilder.append(hexColor1).append(split[i]);
}
hexColor1 = hexColor2;
lastColorMatters = bigger;
i++;
}
if (split.length > i){
stringBuilder.append(hexColor1).append(split[i]);
}
}
return stringBuilder.length()==0 ? message : stringBuilder.toString();
}
public static String removeAllColors(String string) {
for (final String colorCodes : Config.NICK_ALLOWED_COLOR_CODESLIST) {
string = string.replace(colorCodes, "");
}
return string.replaceAll("\\{#[A-Fa-f0-9]{6}(<)?(>)?}", "");
}
static {
NickUtilities.stringRegen = "\\{#[A-Fa-f0-9]{6}(<)?(>)?}";
}
public static String hexGradient(Color color1, Color color2, String text){
double r = color1.getRed();
double g = color1.getGreen();
double b = color1.getBlue();
double rDifference = (color1.getRed() - color2.getRed()) / ((double) text.length() - 1);
double gDifference = (color1.getGreen() - color2.getGreen()) / ((double) text.length() - 1);
double bDifference = (color1.getBlue() - color2.getBlue()) / ((double) text.length() - 1);
StringBuilder stringBuilder = new StringBuilder();
char[] chars = text.toCharArray();
for (int i = 0; i < text.length(); i++) {
if (i > 0) {
r = r - rDifference;
g = g - gDifference;
b = b - bDifference;
}
stringBuilder.append(ChatColor.of(new Color((int) r, (int) g, (int) b))).append(chars[i]);
}
return stringBuilder.toString();
}
public static void updateCache() {
if (!Nicknames.getInstance().nickCacheUpdate.isEmpty()){
Nicknames.getInstance().nickCacheUpdate.forEach(uuid ->{
Nick nick = Queries.getNick(uuid);
if (nick == null){
Nicknames.getInstance().NickCache.remove(uuid);
} else {
Nicknames.getInstance().NickCache.put(uuid, nick);
}
});
}
}
public static boolean validNick(Player sender, OfflinePlayer target, String nickName) {
if (noBlockedCodes(nickName)) {
String cleanNick = NickUtilities.removeAllColors(nickName);
if (cleanNick.length() >= 3 && cleanNick.length() <= 16) {
if (cleanNick.matches("[a-zA-Z0-9_]*") && nickName.length()<=192) {//192 is if someone puts {#xxxxxx<>} in front of every letter
if (!cleanNick.equalsIgnoreCase(target.getName())){
for (Nick nick : Nicknames.getInstance().NickCache.values()){
if (!nick.getUuid().equals(target.getUniqueId())
&& ((nick.getCurrentNickNoColor() != null && nick.getCurrentNickNoColor().equalsIgnoreCase(cleanNick))
|| (nick.getNewNickNoColor() != null && nick.getNewNickNoColor().equalsIgnoreCase(cleanNick)))){
UUID uuid = nick.getUuid();
UUID uniqueId = target.getUniqueId();
if (uniqueId.equals(uuid)){
ChatPlugin.getInstance().getLogger().info(uuid + " " + uniqueId);
}
sender.sendMessage(applyColor(Config.NICK_TAKEN));
return false;
}
}
}
return true;
} else {
sender.sendMessage(applyColor(Config.NICK_INVALID_CHARACTERS));
}
} else {
sender.sendMessage(applyColor(Config.NICK_INVALID_LENGTH));
}
} else {
sender.sendMessage(applyColor(Config.NICK_BLOCKED_COLOR_CODES));
}
return false;
}
public static boolean noBlockedCodes(final String getNick) {
for (final String blockedCodes : Config.NICK_BLOCKED_COLOR_CODESLIST) {
if (getNick.contains(blockedCodes)) {
return false;
}
}
return true;
}
public static void bungeeMessageHandled(UUID uniqueId, Player player, String channel) {
ByteArrayDataOutput out = ByteStreams.newDataOutput();
// out.writeUTF("Forward"); // So BungeeCord knows to forward it
// out.writeUTF("ALL");
out.writeUTF("NickName" + channel); // The channel name to check if this your data
ByteArrayOutputStream msgbytes = new ByteArrayOutputStream();
DataOutputStream msgout = new DataOutputStream(msgbytes);
try {
msgout.writeUTF(uniqueId.toString());
} catch (IOException exception){
exception.printStackTrace();
return;
}
byte[] bytes = msgbytes.toByteArray();
out.writeShort(bytes.length);
out.write(bytes);
player.sendPluginMessage(ChatPlugin.getInstance(), Config.MESSAGECHANNEL, out.toByteArray());
}
}

410
galaxy/src/main/java/com/alttd/chat/nicknames/Nicknames.java Normal file
View File

@ -0,0 +1,410 @@
package com.alttd.chat.nicknames;
import com.alttd.chat.ChatAPI;
import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries;
import com.alttd.chat.events.NickEvent;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Nick;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.luckperms.api.LuckPerms;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.sql.SQLException;
import java.util.*;
public class Nicknames implements CommandExecutor, TabCompleter {
static Nicknames instance;
HashMap<UUID, Nick> NickCache;
ArrayList<UUID> nickCacheUpdate;
public Nicknames() {
instance = this;
NickCache = new HashMap<>();
nickCacheUpdate = new ArrayList<>();
}
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String label, String[] args) {
if (sender instanceof Player player) {
if (args.length == 0) {
sender.sendMessage(format(helpMessage(sender, HelpType.ALL)));
return true;
}
switch (args[0].toLowerCase()) {
case "set":
if (args.length == 2 && hasPermission(sender, "utility.nick.set")) {
handleNick(player, player, args[1]);
} else if (args.length == 3 && hasPermission(sender, "utility.nick.set.others")) {
OfflinePlayer offlinePlayer = sender.getServer().getOfflinePlayer(args[1]);
if (offlinePlayer.isOnline() || offlinePlayer.hasPlayedBefore()) {
handleNick(player, offlinePlayer, args[2]);
} else {
sender.sendMessage(format(helpMessage(sender, HelpType.SET_OTHERS)));
}
} else if (args.length > 3) {
sender.sendMessage(format(helpMessage(sender, HelpType.SET_SELF, HelpType.SET_OTHERS)));
}
break;
case "review":
if (args.length == 1 && hasPermission(sender, "utility.nick.review")) {
NicknamesGui nicknamesGui = new NicknamesGui();
ChatPlugin.getInstance().getServer().getPluginManager().registerEvents(nicknamesGui, ChatPlugin.getInstance());
nicknamesGui.openInventory(player);
} else {
sender.sendMessage(format(helpMessage(sender, HelpType.REVIEW)));
}
break;
case "request":
if (args.length == 2 && hasPermission(sender, "utility.nick.request")) {
new BukkitRunnable() {
@Override
public void run() {
handleNickRequest(player, args[1]);
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
} else {
sender.sendMessage(format(helpMessage(sender, HelpType.REQUEST)));
}
break;
case "try":
if (args.length == 2 && hasPermission(sender, "utility.nick.try")) {
LuckPerms api = ChatAPI.get().getLuckPerms();
if (api != null) {
if (NickUtilities.validNick(player, player, args[1])) {
sender.sendMessage(format(Config.NICK_TRYOUT
.replace("%prefix", api.getUserManager().getUser(player.getUniqueId())
.getCachedData().getMetaData().getPrefix()) // TODO pull this from chatuser?
.replace("%nick%", args[1])));
}
} else {
sender.sendMessage(format(Config.NICK_NO_LUCKPERMS));
}
} else {
sender.sendMessage(format(helpMessage(sender, HelpType.TRY)));
}
break;
case "current":
if (hasPermission(sender, "utility.nick.current")) {
ChatUser chatUser = ChatUserManager.getChatUser(player.getUniqueId());
TagResolver placeholders = TagResolver.resolver(
Placeholder.component("nickname", chatUser.getDisplayName()),
Placeholder.parsed("currentnickname", chatUser.getNickNameString())
);
player.sendMiniMessage(Config.NICK_CURRENT, placeholders);
}
break;
case "help":
sender.sendMessage(format(helpMessage(sender, HelpType.ALL)
+ "For more info on nicknames and how to use rgb colors go to: &bhttps://alttd.com/nicknames&f"));
break;
default:
sender.sendMessage(format(helpMessage(sender, HelpType.ALL)));
}
} else {
sender.sendMessage("Console commands are disabled.");
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
List<String> completions = new ArrayList<>();
if (!sender.hasPermission("utility.nick")) return completions;
if (args.length == 1) {
List<String> choices = new ArrayList<>();
if (sender.hasPermission("utility.nick.set")) {
choices.add("set");
}
if (sender.hasPermission("utility.nick.review")) {
choices.add("review");
}
if (sender.hasPermission("utility.nick.request")) {
choices.add("request");
}
if (sender.hasPermission("utility.nick.try")) {
choices.add("try");
}
if (sender.hasPermission("utility.nick.current")) {
choices.add("current");
}
choices.add("help");
for (String s : choices) {
if (s.startsWith(args[0])) {
completions.add(s);
}
}
} else if (args.length == 2) {
if (args[0].equalsIgnoreCase("set")) {
List<String> choices = new ArrayList<>();
List<String> onlinePlayers = new ArrayList<>();
Bukkit.getOnlinePlayers().forEach(a -> onlinePlayers.add(a.getName()));
if (sender.hasPermission("utility.nick.set.others")) {
choices.addAll(onlinePlayers);
}
for (String s : choices) {
if (s.startsWith(args[1])) {
completions.add(s);
}
}
}
}
return completions;
}
private void handleNickRequest(Player player, String nickName) {
if (!NickUtilities.validNick(player, player, nickName)) {
return;
}
NickUtilities.updateCache();
UUID uniqueId = player.getUniqueId();
if (NickCache.containsKey(uniqueId)) {
Nick nick = NickCache.get(uniqueId);
long timeSinceLastChange = new Date().getTime() - nick.getLastChangedDate();
long waitTime = Config.NICK_WAIT_TIME;
if (timeSinceLastChange > waitTime || player.hasPermission("utility.nick.admin")) {
if (nick.hasRequest()) {
player.sendMessage(format(Config.NICK_REQUEST_PLACED
.replace("%oldRequestedNick%", nick.getNewNick())
.replace("%newRequestedNick%", nickName)));
}
nick.setNewNick(nickName);
nick.setRequestedDate(new Date().getTime());
} else {
player.sendMessage(format(Config.NICK_TOO_SOON
.replace("%time%", formatTime((timeSinceLastChange-waitTime)*-1))));
return;
}
} else {
NickCache.put(uniqueId, new Nick(uniqueId, null, 0, nickName, new Date().getTime()));
}
Queries.newNicknameRequest(uniqueId, nickName);
bungeeMessageRequest(player);
player.sendMessage(format(Config.NICK_REQUESTED
.replace("%nick%", nickName)));
}
private void bungeeMessageRequest(Player player) {
ByteArrayDataOutput out = ByteStreams.newDataOutput();
UUID uniqueId = player.getUniqueId();
// out.writeUTF("Forward"); // So BungeeCord knows to forward it
// out.writeUTF("ALL");
out.writeUTF("NickNameRequest"); // The channel name to check if this your data
ByteArrayOutputStream msgbytes = new ByteArrayOutputStream();
DataOutputStream msgout = new DataOutputStream(msgbytes);
try {
msgout.writeUTF(uniqueId.toString());
} catch (IOException exception) {
exception.printStackTrace();
return;
}
byte[] bytes = msgbytes.toByteArray();
out.writeShort(bytes.length);
out.write(bytes);
player.sendPluginMessage(ChatPlugin.getInstance(), Config.MESSAGECHANNEL, out.toByteArray());
Nicknames.getInstance().nickCacheUpdate.add(uniqueId);
}
private String formatTime(long timeInMillis) {
long second = (timeInMillis / 1000) % 60;
long minute = (timeInMillis / (1000 * 60)) % 60;
long hour = (timeInMillis / (1000 * 60 * 60)) % 24;
long days = (timeInMillis / (1000 * 60 * 60 * 24));
StringBuilder stringBuilder = new StringBuilder();
if (days!=0) {
stringBuilder.append(days).append(" days ");
}
if (days!=0 || hour!=0) {
stringBuilder.append(hour).append(" hours ");
}
if (days!=0 || hour!=0 || minute != 0) {
stringBuilder.append(minute).append(" minutes and ");
}
stringBuilder.append(second).append(" seconds");
return stringBuilder.toString();
}
private void handleNick(Player sender, OfflinePlayer target, final String nickName) {
if (nickName.equalsIgnoreCase("off")) {
try {
if (target.isOnline()) {
resetNick(target.getPlayer());
}
Queries.removePlayerFromDataBase(target.getUniqueId());
NickCache.remove(target.getUniqueId());
nickCacheUpdate.add(target.getUniqueId());
} catch (SQLException e) {
e.printStackTrace();
}
if (!sender.equals(target)) {
sender.sendMessage(format(Config.NICK_RESET_OTHERS
.replace("%player%", target.getName())));
}
if (target.isOnline() && target.getPlayer() != null) {
target.getPlayer().sendMessage(format(Config.NICK_RESET));
}
NickEvent nickEvent = new NickEvent(sender.getName(), target.getName(), null, NickEvent.NickEventType.RESET);
nickEvent.callEvent();
} else if (NickUtilities.validNick(sender, target, nickName)) {
if (target.isOnline()) {
setNick(target.getUniqueId(), nickName);
} else {
NickUtilities.bungeeMessageHandled(target.getUniqueId(), sender, "Set");
}
Queries.setNicknameInDatabase(target.getUniqueId(), nickName);
NickEvent nickEvent = new NickEvent(sender.getName(), target.getName(), nickName, NickEvent.NickEventType.SET);
nickEvent.callEvent();
if (NickCache.containsKey(target.getUniqueId())) {
Nick nick = NickCache.get(target.getUniqueId());
nick.setCurrentNick(nickName);
nick.setLastChangedDate(new Date().getTime());
setNick(target.getUniqueId(), nickName);
} else {
NickCache.put(target.getUniqueId(), new Nick(target.getUniqueId(), nickName, new Date().getTime()));
}
if (!sender.equals(target)) {
sender.sendMessage(format(Config.NICK_CHANGED_OTHERS
.replace("%targetplayer%", target.getName())
.replace("%nickname%", nickName)));
if (target.isOnline()) {
target.getPlayer().sendMessage(format(Config.NICK_TARGET_NICK_CHANGE
.replace("%nickname%", getNick(target.getPlayer()))
.replace("%sendernick%", getNick(sender))
.replace("%player%", target.getName())));
}
} else if (target.isOnline()) {
target.getPlayer().sendMessage(format(Config.NICK_CHANGED
.replace("%nickname%", getNick(target.getPlayer()))));
}
}
}
private String helpMessage(final CommandSender sender, final HelpType... helpTypes) {
StringBuilder message = new StringBuilder();
for (HelpType helpType : helpTypes) {
if (helpType.equals(HelpType.ALL)) {
return helpMessage(sender, helpType);
}
message.append(helpMessage(sender, helpType));
}
return message.toString();
}
private String helpMessage(CommandSender sender, HelpType type) {
StringBuilder message = new StringBuilder();
switch (type) {
case ALL:
message.append(helpMessage(sender, HelpType.SET_SELF));
message.append(helpMessage(sender, HelpType.SET_OTHERS));
message.append(helpMessage(sender, HelpType.REQUEST));
message.append(helpMessage(sender, HelpType.REVIEW));
message.append(helpMessage(sender, HelpType.TRY));
break;
case SET_SELF:
if (sender.hasPermission("utility.nick.set")) {
message.append("&6/nick set <nickname>&f - Sets your nickname to the specified name.\n");
}
break;
case SET_OTHERS:
if (sender.hasPermission("utility.nick.set.others")) {
message.append("&6/nick set <username> <nickname>&f - Sets the specified user's nickname to the specified name.\n");
}
break;
case REQUEST:
if (sender.hasPermission("utility.nick.request")) {
message.append("&6/nick request <nickname>&f - Requests a username to be reviewed by staff.\n" +
" &7Try using &8/nick try <nickname>&7 to see if you like the name, you can only change it once per day!\n");
}
break;
case REVIEW:
if (sender.hasPermission("utility.nick.review")) {
message.append("&6/nick review&f - Opens the nickname review GUI (left click to accept a nick, right click to deny it)\n");
}
break;
case TRY:
if (sender.hasPermission("utility.nick.try")) {
message.append("&6/nick try <nickname>&f - Shows you what your nickname will look like in chat.\n");
}
}
return message.toString();
}
private boolean hasPermission(CommandSender sender, String permission) {
if (!sender.hasPermission(permission)) {
sender.sendMessage(format(Config.NO_PERMISSION));
return false;
}
return true;
}
public void resetNick(final Player player) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
user.setDisplayName(player.getName());
}
public String getNick(final Player player) {
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
return user.getNickNameString();
}
public void setNick(final UUID uuid, final String nickName) {
ChatUser user = ChatUserManager.getChatUser(uuid);
user.setDisplayName(nickName);
}
public static String format(final String m) {
return NickUtilities.applyColor(m);
}
public static Nicknames getInstance() {
return Nicknames.instance;
}
private enum HelpType {
ALL,
SET_SELF,
SET_OTHERS,
REVIEW,
REQUEST,
TRY
}
}

192
galaxy/src/main/java/com/alttd/chat/nicknames/NicknamesEvents.java Normal file
View File

@ -0,0 +1,192 @@
package com.alttd.chat.nicknames;
import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries;
import com.alttd.chat.objects.Nick;
import com.alttd.chat.util.ALogger;
import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteStreams;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.ClickEvent;
import net.md_5.bungee.api.chat.ComponentBuilder;
import net.md_5.bungee.api.chat.HoverEvent;
import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.plugin.messaging.PluginMessageListener;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.util.UUID;
public class NicknamesEvents implements Listener, PluginMessageListener {
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onPlayerJoin(PlayerJoinEvent e) {
new BukkitRunnable() {
@Override
public void run() {
if (Nicknames.instance.NickCache.isEmpty()) {
Queries.getNicknamesList().forEach(nick -> Nicknames.instance.NickCache.put(nick.getUuid(), nick));
}
final Player player = e.getPlayer();
final Nick nick = Queries.getNick(player.getUniqueId());
if (nick == null) {
Nicknames.getInstance().resetNick(player);
return;
}
String nickName = nick.getCurrentNick();
String strippedNick = Nicknames.getInstance().getNick(player);
// try {
// strippedNick = MiniMessage.miniMessage().stripTokens(Nicknames.getInstance().getNick(player));
// } catch (NullPointerException ignored) {
// }
// final String strippedNick = CMIChatColor.stripColor(Nicknames.getInstance().getNick(player));
//final String cmiNick = Util.CMIChatColor.deColorize(Nicknames.getInstance().getNick(player));
if (nickName == null) {
Nicknames.getInstance().resetNick(player);
} else if (!nickName.equals(strippedNick)) {
Nicknames.getInstance().setNick(player.getUniqueId(), nickName);
}
Nicknames.getInstance().NickCache.put(e.getPlayer().getUniqueId(), nick);
if (player.hasPermission("utility.nick.review")) {
int i = 0;
for (Nick iNick : Nicknames.getInstance().NickCache.values()) {
if (iNick.hasRequest()) {
i++;
}
}
if (i > 0) {
player.sendMessage(format(Config.NICK_REQUESTS_ON_LOGIN
.replace("%amount%", String.valueOf(i))));
}
}
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
}
@Override
public void onPluginMessageReceived(String channel, @NotNull Player player, byte[] message) {
if (!channel.equals(Config.MESSAGECHANNEL)) {
return;
}
ByteArrayDataInput in = ByteStreams.newDataInput(message);
String subChannel = in.readUTF();
ALogger.info(channel + ": " + subChannel);
if (!subChannel.equals("NickNameRequest") && !subChannel.equals("NickNameAccepted")
&& !subChannel.equals("NickNameDenied") && !subChannel.equals("NickNameSet")) {
return;
}
UUID playerUUID;
OfflinePlayer offlinePlayer;
String name;
try {
short len = in.readShort();
byte[] msgbytes = new byte[len];
in.readFully(msgbytes);
DataInputStream msgin = new DataInputStream(new ByteArrayInputStream(msgbytes));
playerUUID = UUID.fromString(msgin.readUTF());
offlinePlayer = ChatPlugin.getInstance().getServer().getOfflinePlayer(playerUUID);
name = offlinePlayer.getName() == null ? playerUUID.toString() : offlinePlayer.getName();
} catch (Exception e) {
e.printStackTrace();
return;
}
switch (subChannel) {
case "NickNameRequest":
String notification = NickUtilities.applyColor(Config.NICK_REQUEST_NEW
.replace("%player%", name));
TextComponent component = new TextComponent(TextComponent.fromLegacyText(NickUtilities.applyColor(notification)));
component.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/nick review"));
component.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
new ComponentBuilder(NickUtilities.applyColor("&6Click this text to review the request!")).create()));
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("utility.nick.review")) {
p.sendMessage(component);
}
});
Nicknames.getInstance().nickCacheUpdate.add(playerUUID);
if (offlinePlayer.isOnline()) {
Nick nick = Queries.getNick(playerUUID);
if (nick != null && nick.getCurrentNick() != null) {
Nicknames.getInstance().setNick(offlinePlayer.getUniqueId(), nick.getCurrentNick());
}
}
break;
case "NickNameAccepted":
final String messageAccepted = ChatColor.GREEN + name + "'s nickname was accepted!";
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("utility.nick.review")) {
p.sendMessage(messageAccepted);
}
});
//No break on purpose
case "NickNameSet":
Nicknames.getInstance().nickCacheUpdate.add(playerUUID);
if (offlinePlayer.isOnline()) {
Nick nick = Queries.getNick(playerUUID);
Player target = Bukkit.getPlayer(playerUUID);
if (target != null && nick != null && nick.getCurrentNick() != null) {
Nicknames.getInstance().setNick(target.getUniqueId(), nick.getCurrentNick());
target.sendMessage(format(Config.NICK_CHANGED
.replace("%nickname%", nick.getCurrentNick())));
}
}
break;
case "NickNameDenied":
final String messageDenied = ChatColor.RED + name + "'s nickname was denied!";
Nick nick = Nicknames.getInstance().NickCache.get(playerUUID);
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("utility.nick.review")) {
p.sendMessage(messageDenied);
}
});
if (nick.getCurrentNick() == null) {
Nicknames.getInstance().NickCache.remove(playerUUID);
} else {
nick.setNewNick(null);
nick.setRequestedDate(0);
Nicknames.getInstance().NickCache.put(playerUUID, nick);
}
if (offlinePlayer.isOnline()) {
Player target = Bukkit.getPlayer(playerUUID);
if (target == null) break;
target.sendMessage(format(Config.NICK_NOT_CHANGED
.replace("%nickname%", nick.getCurrentNick())));
}
break;
}
}
public static String format(final String m) {
return NickUtilities.applyColor(m);
}
}

285
galaxy/src/main/java/com/alttd/chat/nicknames/NicknamesGui.java Normal file
View File

@ -0,0 +1,285 @@
package com.alttd.chat.nicknames;
import com.alttd.chat.ChatPlugin;
import com.alttd.chat.config.Config;
import com.alttd.chat.database.Queries;
import com.alttd.chat.events.NickEvent;
import com.alttd.chat.objects.Nick;
import com.alttd.chat.util.Utility;
import net.kyori.adventure.text.Component;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.inventory.meta.SkullMeta;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import static com.alttd.chat.nicknames.Nicknames.format;
public class NicknamesGui implements Listener {
private final Inventory inv;
private final int currentPage;
public NicknamesGui() {
// Create a new inventory, with no owner (as this isn't a real inventory)
inv = Bukkit.createInventory(null, 36, Utility.parseMiniMessage("Nicknames GUI"));
// Put the items into the inventory
currentPage = 1;
setItems(currentPage);
}
public void setItems(int currentPage) {
new BukkitRunnable() {
@Override
public void run() {
inv.clear();
NickUtilities.updateCache();
boolean hasNextPage = false;
int i = (currentPage - 1) * 27; //TODO set to 1 or 2 to test
int limit = i / 27;
for (Nick nick : Nicknames.getInstance().NickCache.values()) {
if (nick.hasRequest()) {
if (limit >= i / 27) {
inv.setItem(i % 27, createPlayerSkull(nick, Config.NICK_ITEM_LORE));
i++;
} else {
hasNextPage = true;
break;
}
}
}
if (currentPage != 1) {
inv.setItem(28, createGuiItem(Material.PAPER, "§bPrevious page",
"§aCurrent page: %page%".replace("%page%", String.valueOf(currentPage)),
"§aPrevious page: %previousPage%".replace("%previousPage%", String.valueOf(currentPage - 1))));
}
if (hasNextPage) {
inv.setItem(36, createGuiItem(Material.PAPER, "§bNext page",
"§aCurrent page: %page%".replace("%page%", String.valueOf(currentPage)),
"§aNext page: §b%nextPage%".replace("%nextPage%", String.valueOf(currentPage + 1))));
}
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
}
private ItemStack createPlayerSkull(Nick nick, List<String> lore) {
ItemStack playerHead = new ItemStack(Material.PLAYER_HEAD);
SkullMeta meta = (SkullMeta) playerHead.getItemMeta();
OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(nick.getUuid());
meta.setOwningPlayer(offlinePlayer);
meta.setDisplayName(offlinePlayer.getName());
lore.replaceAll(s -> format(s
.replace("%newNick%", nick.getNewNick())
.replace("%oldNick%", nick.getCurrentNick() == null ? "None" : nick.getCurrentNick())
.replace("%lastChanged%", nick.getLastChangedDate() == 0 ? "Not Applicable" : nick.getLastChangedDateFormatted())));
meta.setLore(lore);
playerHead.setItemMeta(meta);
return playerHead;
}
// Nice little method to create a gui item with a custom name, and description
private ItemStack createGuiItem(final Material material, final String name, final String... lore) {
final ItemStack item = new ItemStack(material, 1);
final ItemMeta meta = item.getItemMeta();
// Set the name of the item
meta.displayName(Component.text(name));
// Set the lore of the item
meta.setLore(Arrays.asList(lore));
item.setItemMeta(meta);
return item;
}
// You can open the inventory with this
public void openInventory(final HumanEntity ent) {//Possibly with a boolean to show if it should get from cache or update cache
ent.openInventory(inv);
}
// Check for clicks on items
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onInventoryClick(InventoryClickEvent e) {
if (e.getInventory() != inv) return;
e.setCancelled(true);
final ItemStack clickedItem = e.getCurrentItem();
if (clickedItem == null || clickedItem.getType() == Material.AIR) return;
final Player p = (Player) e.getWhoClicked();
if (clickedItem.getType().equals(Material.PAPER)) {
if (clickedItem.getItemMeta().getDisplayName().equals("Next Page")) {
setItems(currentPage + 1);
}
} else if (clickedItem.getType().equals(Material.PLAYER_HEAD)) {
SkullMeta meta = (SkullMeta) clickedItem.getItemMeta();
if (meta.hasEnchants()) {
return;
}
OfflinePlayer owningPlayer = meta.getOwningPlayer();
if (owningPlayer == null) {
p.sendMessage(format(Config.NICK_USER_NOT_FOUND));
return;
}
new BukkitRunnable() {
@Override
public void run() {
NickUtilities.updateCache();
Nick nick;
UUID uniqueId = owningPlayer.getUniqueId();
if (Nicknames.getInstance().NickCache.containsKey(uniqueId)) {
nick = Nicknames.getInstance().NickCache.get(uniqueId);
} else {
nick = Queries.getNick(uniqueId);
}
if (nick == null || !nick.hasRequest()) {
p.sendMessage(format(Config.NICK_ALREADY_HANDLED
.replace("%targetPlayer%", clickedItem.getItemMeta().getDisplayName())));
return;
}
if (e.isLeftClick()) {
if (owningPlayer.hasPlayedBefore()) {
Queries.acceptNewNickname(uniqueId, nick.getNewNick());
String newNick = nick.getNewNick();
new BukkitRunnable() {
@Override
public void run() {
NickEvent nickEvent = new NickEvent(e.getWhoClicked().getName(), clickedItem.getItemMeta().getDisplayName(), newNick, NickEvent.NickEventType.ACCEPTED);
nickEvent.callEvent();
}
}.runTask(ChatPlugin.getInstance());
p.sendMessage(format(Config.NICK_ACCEPTED
.replace("%targetPlayer%", clickedItem.getItemMeta().getDisplayName())
.replace("%newNick%", nick.getNewNick())
.replace("%oldNick%", nick.getCurrentNick() == null ? clickedItem.getItemMeta().getDisplayName() : nick.getCurrentNick())));
if (owningPlayer.isOnline() && owningPlayer.getPlayer() != null) {
Nicknames.getInstance().setNick(owningPlayer.getUniqueId(), nick.getNewNick());
// owningPlayer.getPlayer().sendMessage(format(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");
nick.setCurrentNick(nick.getNewNick());
nick.setLastChangedDate(new Date().getTime());
nick.setNewNick(null);
nick.setRequestedDate(0);
Nicknames.getInstance().NickCache.put(uniqueId, nick);
ItemStack itemStack = new ItemStack(Material.SKELETON_SKULL);
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.displayName(clickedItem.getItemMeta().displayName());
itemMeta.lore(clickedItem.lore());
itemStack.setItemMeta(itemMeta);
e.getInventory().setItem(e.getSlot(), itemStack);
p.updateInventory();
} else {
p.sendMessage(format(Config.NICK_PLAYER_NOT_ONLINE
.replace("%playerName%", clickedItem.getItemMeta().getDisplayName())));
}
} else if (e.isRightClick()) {
if (owningPlayer.hasPlayedBefore()) {
Queries.denyNewNickname(uniqueId);
String newNick = nick.getNewNick();
new BukkitRunnable() {
@Override
public void run() {
NickEvent nickEvent = new NickEvent(e.getWhoClicked().getName(), clickedItem.getItemMeta().getDisplayName(), newNick, NickEvent.NickEventType.DENIED);
nickEvent.callEvent();
}
}.runTask(ChatPlugin.getInstance());
p.sendMessage(format(Config.NICK_DENIED
.replace("%targetPlayer%", owningPlayer.getName())
.replace("%newNick%", nick.getNewNick())
.replace("%oldNick%", nick.getCurrentNick() == null ? owningPlayer.getName() : nick.getCurrentNick())));
if (Nicknames.getInstance().NickCache.containsKey(uniqueId)
&& Nicknames.getInstance().NickCache.get(uniqueId).getCurrentNick() != null) {
nick.setNewNick(null);
nick.setRequestedDate(0);
Nicknames.getInstance().NickCache.put(uniqueId, nick);
} else {
Nicknames.getInstance().NickCache.remove(uniqueId);
}
if (owningPlayer.isOnline() && owningPlayer.getPlayer() != null) {
Nicknames.getInstance().setNick(owningPlayer.getUniqueId(), nick.getCurrentNick() == null ? owningPlayer.getName() : nick.getCurrentNick());
owningPlayer.getPlayer().sendMessage(format(Config.NICK_NOT_CHANGED));
}
NickUtilities.bungeeMessageHandled(uniqueId, e.getWhoClicked().getServer().getPlayer(e.getWhoClicked().getName()), "Denied");
final String messageDenied = ChatColor.RED + owningPlayer.getName() + "'s nickname was denied!";
ChatPlugin.getInstance().getServer().getOnlinePlayers().forEach(p -> {
if (p.hasPermission("utility.nick.review")) {
p.sendMessage(messageDenied);
}
});
ItemStack itemStack = new ItemStack(Material.SKELETON_SKULL);
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.displayName(clickedItem.getItemMeta().displayName());
itemMeta.lore(clickedItem.lore());
itemStack.setItemMeta(itemMeta);
e.getInventory().setItem(e.getSlot(), itemStack);
p.updateInventory();
} else {
p.sendMessage(format(Config.NICK_PLAYER_NOT_ONLINE
.replace("%playerName%", clickedItem.getItemMeta().getDisplayName())));
}
}
}
}.runTaskAsynchronously(ChatPlugin.getInstance());
}
}
// Cancel dragging in our inventory
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onInventoryClick(InventoryDragEvent e) {
if (e.getInventory() == inv) {
e.setCancelled(true);
}
}
}

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

@ -1,13 +1,19 @@
package com.alttd.chat.util;
import com.alttd.chat.config.Config;
import com.alttd.chat.managers.RegexManager;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.TextDecoration;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class GalaxyUtility {
public static void sendBlockedNotification(String prefix, Player player, String input, String target) {
@ -32,4 +38,14 @@ public class GalaxyUtility {
sendBlockedNotification(prefix, player, PlainTextComponentSerializer.plainText().serialize(input), target);
}
public static void addAdditionalChatCompletions(Player player) {
List<String> completions = new ArrayList<>(RegexManager.emotesList);
Utility.formattingPerms.forEach((perm, pair) -> {
if (player.hasPermission(perm)) {
completions.addAll(pair.getY());
}
});
player.addAdditionalChatCompletions(completions);
}
}

9
galaxy/src/main/resources/plugin.yml
View File

@ -1,5 +1,5 @@
name: ChatPlugin
version: ${project.version}
version: 2.0.0-SNAPSHOT
main: com.alttd.chat.ChatPlugin
api-version: 1.18
authors: [Destro, Teriuihi]
@ -33,4 +33,9 @@ commands:
p:
permission: command.chat.p
chatclear:
permission: chat.command.clear-chat
permission: chat.command.clear-chat
emoteslist:
permission: chat.command.clear-chat
aliases: [emotes]
nick:
permission: chat.command.nick

2
velocity/build.gradle.kts
View File

@ -26,7 +26,7 @@ tasks {
}
build {
setBuildDir("${rootProject.buildDir}")
// setBuildDir("${rootProject.buildDir}")
dependsOn(shadowJar)
}

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

@ -10,6 +10,7 @@ import com.alttd.velocitychat.commands.SubCommand;
import com.velocitypowered.api.command.CommandSource;
import com.velocitypowered.api.proxy.Player;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.JoinConfiguration;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
@ -49,7 +50,7 @@ public class Info implements SubCommand {
Placeholder.unparsed("party", party.getPartyName()),
Placeholder.unparsed("password", party.getPartyPassword()),
Placeholder.component("owner", party.getPartyUser(party.getOwnerUuid()).getDisplayName()),
Placeholder.component("members", Component.join(Component.text(", "), displayNames))
Placeholder.component("members", Component.join(JoinConfiguration.separator(Component.text(", ")), displayNames))
));
}

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

@ -5,10 +5,7 @@ import com.alttd.chat.database.Queries;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.managers.PartyManager;
import com.alttd.chat.managers.RegexManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.chat.objects.Mail;
import com.alttd.chat.objects.ModifiableString;
import com.alttd.chat.objects.Party;
import com.alttd.chat.objects.*;
import com.alttd.chat.util.ALogger;
import com.alttd.chat.util.Utility;
import com.alttd.velocitychat.VelocityChat;
@ -19,6 +16,7 @@ import com.velocitypowered.api.proxy.Player;
import com.velocitypowered.api.proxy.ServerConnection;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextReplacementConfig;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
@ -108,6 +106,8 @@ public class ChatHandler {
return party.getPartyUsers().stream().anyMatch(pu -> pu.getUuid().equals(uuid));
}).forEach(pl -> {
pl.sendMessage(message);
// TODO forward sound to backend server.
// https://canary.discord.com/channels/514920774923059209/1020498592219271189
});
}
@ -128,18 +128,11 @@ public class ChatHandler {
return; // the message was blocked
}
String updatedMessage = modifiableString.string();
if(!player.hasPermission("chat.format")) {
updatedMessage = Utility.stripTokens(updatedMessage);
}
updatedMessage = Utility.formatText(updatedMessage);
TagResolver Placeholders = TagResolver.resolver(
Placeholder.component("sender", senderName),
Placeholder.component("sendername", senderName),
Placeholder.unparsed("partyname", party.getPartyName()),
Placeholder.component("message", Utility.parseMiniMessage(updatedMessage)),
Placeholder.component("message", parseMessageContent(player, modifiableString.string())),
Placeholder.unparsed("server", serverConnection.getServer().getServerInfo().getName())
);
@ -175,7 +168,7 @@ public class ChatHandler {
}
TagResolver Placeholders = TagResolver.resolver(
Placeholder.component("message", Utility.parseMiniMessage(message)),
Placeholder.component("message", parseMessageContent(commandSource, message)),
Placeholder.component("sender", senderName),
Placeholder.unparsed("server", serverName));
@ -297,4 +290,27 @@ public class ChatHandler {
stringBuilder.append(duration.toMinutesPart()).append("m ago");
return stringBuilder.toString();
}
private Component parseMessageContent(CommandSource source, String rawMessage) {
TagResolver.Builder tagResolver = TagResolver.builder();
Utility.formattingPerms.forEach((perm, pair) -> {
if (source.hasPermission(perm)) {
tagResolver.resolver(pair.getX());
}
});
MiniMessage miniMessage = MiniMessage.builder().tags(tagResolver.build()).build();
Component component = miniMessage.deserialize(rawMessage);
for(ChatFilter chatFilter : RegexManager.getEmoteFilters()) {
component = component.replaceText(
TextReplacementConfig.builder()
.times(Config.EMOTELIMIT)
.match(chatFilter.getRegex())
.replacement(chatFilter.getReplacement()).build());
}
return component;
}
}

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

@ -2,10 +2,9 @@ package com.alttd.velocitychat.listeners;
import com.alttd.chat.managers.ChatUserManager;
import com.alttd.chat.objects.ChatUser;
import com.alttd.velocitychat.VelocityChat;
import com.alttd.chat.database.Queries;
import com.alttd.chat.objects.channels.CustomChannel;
import com.alttd.chat.util.ALogger;
import com.alttd.velocitychat.VelocityChat;
import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteStreams;
import com.velocitypowered.api.event.Subscribe;
@ -23,7 +22,6 @@ import java.util.UUID;
public class PluginMessageListener {
//todo add an extra listener for nicknames?
private final ChannelIdentifier identifier;
public PluginMessageListener(ChannelIdentifier identifier){
@ -45,38 +43,33 @@ public class PluginMessageListener {
String channel = in.readUTF();
VelocityChat.getPlugin().getLogger().info("server " + event.getSource());
switch (channel) {
case "globalchat":
VelocityChat.getPlugin().getServerHandler().sendGlobalChat(in.readUTF(), in.readUTF());
break;
case "globaladminchat":
VelocityChat.getPlugin().getChatHandler().globalAdminChat(in.readUTF());
break;
case "privatemessage":
VelocityChat.getPlugin().getChatHandler().privateMessage(in.readUTF(), in.readUTF(), in.readUTF());
break;
case "chatchannel": {
case "globalchat" -> VelocityChat.getPlugin().getServerHandler().sendGlobalChat(in.readUTF(), in.readUTF());
case "globaladminchat" -> VelocityChat.getPlugin().getChatHandler().globalAdminChat(in.readUTF());
case "privatemessage" ->
VelocityChat.getPlugin().getChatHandler().privateMessage(in.readUTF(), in.readUTF(), in.readUTF());
case "chatchannel" -> {
String channelName = in.readUTF();
CustomChannel chatChannel = (CustomChannel) CustomChannel.getChatChannel(channelName);
if (chatChannel == null) {
ALogger.warn("Received non existent channel" + channelName +".");
ALogger.warn("Received non existent channel" + channelName + ".");
break;
}
ProxyServer proxy = VelocityChat.getPlugin().getProxy();
chatChannel.getServers().forEach(server -> proxy.getServer(server).ifPresent(registeredServer ->
registeredServer.sendPluginMessage(VelocityChat.getPlugin().getChannelIdentifier(), event.getData())));
break;
}
case "party": {
case "party" -> {
VelocityChat.getPlugin().getChatHandler().sendPartyMessage(
UUID.fromString(in.readUTF()),
in.readUTF(),
GsonComponentSerializer.gson().deserialize(in.readUTF()),
serverConnection);
break;
}
case "NickNameAccepted": {
// nicknames WIP
case "NickNameAccepted", "NickNameSet" -> {
try {
short len = in.readShort();
byte[] msgbytes = new byte[len];
@ -91,15 +84,22 @@ public class PluginMessageListener {
e.printStackTrace();
return;
}
ProxyServer proxy = VelocityChat.getPlugin().getProxy();
proxy.getAllServers().forEach(registeredServer ->
registeredServer.sendPluginMessage(VelocityChat.getPlugin().getChannelIdentifier(), event.getData()));
}
default:
case "NickNameRequest", "NickNameDenied" -> {
ProxyServer proxy = VelocityChat.getPlugin().getProxy();
proxy.getAllServers().forEach(registeredServer ->
registeredServer.sendPluginMessage(VelocityChat.getPlugin().getChannelIdentifier(), event.getData()));
}
default -> {
VelocityChat.getPlugin().getLogger().info("server " + event.getSource());
ProxyServer proxy = VelocityChat.getPlugin().getProxy();
for (RegisteredServer registeredServer : proxy.getAllServers()) {
registeredServer.sendPluginMessage(VelocityChat.getPlugin().getChannelIdentifier(), event.getData());
}
break;
}
}
}