444 lines
19 KiB
Java
444 lines
19 KiB
Java
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.alttd.chat.util.Utility;
|
|
import com.google.common.io.ByteArrayDataOutput;
|
|
import com.google.common.io.ByteStreams;
|
|
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.plugin.Plugin;
|
|
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(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL)));
|
|
return true;
|
|
}
|
|
switch (args[0].toLowerCase()) {
|
|
case "set":
|
|
if (args.length == 2 && hasPermission(sender, "chat.command.nick.set")) {
|
|
handleNick(player, player, args[1]);
|
|
} else if (args.length == 3 && hasPermission(sender, "chat.command.nick.set.others")) {
|
|
OfflinePlayer offlinePlayer = sender.getServer().getOfflinePlayer(args[1]);
|
|
|
|
if (offlinePlayer.isOnline() || offlinePlayer.hasPlayedBefore()) {
|
|
handleNick(player, offlinePlayer, args[2]);
|
|
} else {
|
|
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.SET_OTHERS)));
|
|
}
|
|
} else if (args.length > 3) {
|
|
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.SET_SELF, HelpType.SET_OTHERS)));
|
|
}
|
|
break;
|
|
case "review":
|
|
if (args.length == 1 && hasPermission(sender, "chat.command.nick.review")) {
|
|
NicknamesGui nicknamesGui = new NicknamesGui();
|
|
ChatPlugin.getInstance().getServer().getPluginManager().registerEvents(nicknamesGui, ChatPlugin.getInstance());
|
|
nicknamesGui.openInventory(player);
|
|
} else {
|
|
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.REVIEW)));
|
|
}
|
|
break;
|
|
case "request":
|
|
if (args.length == 2 && hasPermission(sender, "chat.command.nick.request")) {
|
|
new BukkitRunnable() {
|
|
@Override
|
|
public void run() {
|
|
handleNickRequest(player, args[1]);
|
|
}
|
|
}.runTaskAsynchronously(ChatPlugin.getInstance());
|
|
} else {
|
|
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.REQUEST)));
|
|
}
|
|
break;
|
|
case "try":
|
|
if (args.length == 2 && hasPermission(sender, "chat.command.nick.try")) {
|
|
LuckPerms api = ChatAPI.get().getLuckPerms();
|
|
if (api != null) {
|
|
if (NickUtilities.validNick(player, player, args[1])) {
|
|
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_TRYOUT,
|
|
Placeholder.component("prefix", Utility.applyColor(api.getUserManager().getUser(player.getUniqueId())
|
|
.getCachedData().getMetaData().getPrefix())), // TODO pull this from chatuser?
|
|
Placeholder.component("nick", Utility.applyColor(args[1]))));
|
|
}
|
|
} else {
|
|
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_NO_LUCKPERMS));
|
|
}
|
|
} else {
|
|
sender.sendMessage(Utility.parseMiniMessage(helpMessage(sender, HelpType.TRY)));
|
|
}
|
|
break;
|
|
case "current":
|
|
if (hasPermission(sender, "chat.command.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(Utility.parseMiniMessage(helpMessage(sender, HelpType.ALL)
|
|
+ "For more info on nicknames and how to use rgb colors go to: <aqua>https://alttd.com/nicknames<white>"));
|
|
break;
|
|
default:
|
|
sender.sendMessage(Utility.parseMiniMessage(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("chat.command.nick")) return completions;
|
|
|
|
if (args.length == 1) {
|
|
List<String> choices = new ArrayList<>();
|
|
if (sender.hasPermission("chat.command.nick.set")) {
|
|
choices.add("set");
|
|
}
|
|
if (sender.hasPermission("chat.command.nick.review")) {
|
|
choices.add("review");
|
|
}
|
|
if (sender.hasPermission("chat.command.nick.request")) {
|
|
choices.add("request");
|
|
}
|
|
if (sender.hasPermission("chat.command.nick.try")) {
|
|
choices.add("try");
|
|
}
|
|
if (sender.hasPermission("chat.command.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("chat.command.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("chat.command.nick.bypasswaittime")) {
|
|
if (nick.hasRequest()) {
|
|
player.sendMessage(Utility.parseMiniMessage(Config.NICK_REQUEST_PLACED,
|
|
Placeholder.component("oldrequestednick", Utility.applyColor(nick.getNewNick())),
|
|
Placeholder.component("newrequestednick", Utility.applyColor(nickName))));
|
|
}
|
|
nick.setNewNick(nickName);
|
|
nick.setRequestedDate(new Date().getTime());
|
|
} else {
|
|
player.sendMessage(Utility.parseMiniMessage(Config.NICK_TOO_SOON,
|
|
Placeholder.unparsed("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(Utility.parseMiniMessage(Config.NICK_REQUESTED,
|
|
Placeholder.component("nick", Utility.applyColor(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(Utility.parseMiniMessage(Config.NICK_RESET_OTHERS,
|
|
Placeholder.unparsed("player", target.getName())));
|
|
}
|
|
|
|
if (target.isOnline() && target.getPlayer() != null) {
|
|
target.getPlayer().sendMessage(Utility.parseMiniMessage(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.getPlayer(), 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.getPlayer(), nickName);
|
|
} else {
|
|
NickCache.put(target.getUniqueId(), new Nick(target.getUniqueId(), nickName, new Date().getTime()));
|
|
}
|
|
|
|
if (!sender.equals(target)) {
|
|
sender.sendMessage(Utility.parseMiniMessage(Config.NICK_CHANGED_OTHERS,
|
|
Placeholder.unparsed("targetplayer", target.getName()),
|
|
Placeholder.unparsed("nickname", nickName)));
|
|
if (target.isOnline()) {
|
|
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_TARGET_NICK_CHANGE,
|
|
Placeholder.unparsed("nickname", getNick(target.getPlayer())),
|
|
Placeholder.unparsed("sendernick", getNick(sender)),
|
|
Placeholder.unparsed("player", target.getName())));
|
|
}
|
|
} else if (target.isOnline()) {
|
|
target.getPlayer().sendMessage(Utility.parseMiniMessage(Config.NICK_CHANGED,
|
|
Placeholder.unparsed("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("chat.command.nick.set")) {
|
|
message.append("<gold>/nick set <nickname><white> - Sets your nickname to the specified name.\n");
|
|
}
|
|
break;
|
|
case SET_OTHERS:
|
|
if (sender.hasPermission("chat.command.nick.set.others")) {
|
|
message.append("<gold>/nick set <username> <nickname><white> - Sets the specified user's nickname to the specified name.\n");
|
|
}
|
|
break;
|
|
case REQUEST:
|
|
if (sender.hasPermission("chat.command.nick.request")) {
|
|
message.append("<gold>/nick request <nickname><white> - Requests a username to be reviewed by staff.\n" +
|
|
" <gray>Try using <dark_gray>/nick try <nickname><gray> to see if you like the name, you can only change it once per day!\n");
|
|
}
|
|
break;
|
|
case REVIEW:
|
|
if (sender.hasPermission("chat.command.nick.review")) {
|
|
message.append("<gold>/nick review<white> - Opens the nickname review GUI (left click to accept a nick, right click to deny it)\n");
|
|
}
|
|
break;
|
|
case TRY:
|
|
if (sender.hasPermission("chat.command.nick.try")) {
|
|
message.append("<gold>/nick try <nickname><white> - 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(Utility.parseMiniMessage(Config.NO_PERMISSION));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void resetNick(final Player player) {
|
|
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
|
|
user.setDisplayName(player.getName());
|
|
player.displayName(user.getDisplayName());
|
|
// updateCMIUser(player, null);
|
|
}
|
|
|
|
public String getNick(final Player player) {
|
|
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
|
|
return user.getNickNameString();
|
|
}
|
|
|
|
public void setNick(final Player player, final String nickName) {
|
|
if (player == null)
|
|
return;
|
|
|
|
ChatUser user = ChatUserManager.getChatUser(player.getUniqueId());
|
|
user.setDisplayName(nickName);
|
|
player.displayName(user.getDisplayName());
|
|
// updateCMIUser(player, nickName);
|
|
}
|
|
|
|
// public static String format(final String m) {
|
|
// return NickUtilities.applyColor(m);
|
|
// }
|
|
|
|
// public void updateCMIUser(Player player, String nickName) {
|
|
// if (!isCMIEnabled())
|
|
// return;
|
|
//
|
|
// CMIUser cmiUser = CMI.getInstance().getPlayerManager().getUser(player);
|
|
// if (nickName == null){
|
|
// cmiUser.setNickName(null, true);
|
|
// } else {
|
|
// cmiUser.setNickName(NickUtilities.applyColor(nickName), true);
|
|
// }
|
|
// cmiUser.updateDisplayName();
|
|
// }
|
|
|
|
private Boolean isCMIEnabled = null;
|
|
private Boolean isCMIEnabled() {
|
|
if (!(isCMIEnabled == null))
|
|
return isCMIEnabled;
|
|
|
|
Plugin plugin = Bukkit.getPluginManager().getPlugin("CMI");
|
|
if (plugin != null && plugin.isEnabled())
|
|
return isCMIEnabled = true;
|
|
|
|
return isCMIEnabled = false;
|
|
}
|
|
|
|
public static Nicknames getInstance() {
|
|
return Nicknames.instance;
|
|
}
|
|
|
|
private enum HelpType {
|
|
ALL,
|
|
SET_SELF,
|
|
SET_OTHERS,
|
|
REVIEW,
|
|
REQUEST,
|
|
TRY
|
|
}
|
|
}
|