package com.lifeknight.relaymcbungeemain; import com.google.common.io.ByteArrayDataInput; import com.google.common.io.ByteStreams; import com.google.gson.JsonArray; import com.google.gson.JsonObject; import com.lifeknight.relaymcbungeemain.commands.amenities.*; import com.lifeknight.relaymcbungeemain.commands.chat.*; import com.lifeknight.relaymcbungeemain.commands.game.*; import com.lifeknight.relaymcbungeemain.commands.links.*; import com.lifeknight.relaymcbungeemain.commands.staff.*; import com.lifeknight.relaymcbungeemain.commands.staff.punishments.*; import com.lifeknight.relaymcbungeemain.network.MessageServer; import com.lifeknight.relaymcbungeemain.network.MessageServerHandler; import com.lifeknight.relaymcbungeemain.network.ServerMessageProcessor; import com.lifeknight.relaymcbungeemain.player.SmartPlayer; import com.lifeknight.relaymcbungeemain.queue.GameServer; import com.lifeknight.relaymcbungeemain.queue.Queue; import com.lifeknight.relaymcbungeemain.queue.ServerDetails; import com.lifeknight.relaymcbungeemain.utilities.*; import com.lifeknight.relayutils.RelayUtils; import com.lifeknight.relayutils.basic.Miscellaneous; import com.lifeknight.relayutils.basic.Text; import com.lifeknight.relayutils.data.QueueData; import com.lifeknight.relayutils.game.GameDetails; import com.lifeknight.relayutils.game.GameType; import com.lifeknight.relayutils.game.MainGame; import com.lifeknight.relayutils.network.Command; import com.lifeknight.relayutils.network.Message; import com.lifeknight.relayutils.network.Recipient; import com.lifeknight.relayutils.player.data.SmartDatabase; import com.lifeknight.relayutils.utilities.ComponentBuilder; import net.md_5.bungee.api.ChatColor; import net.md_5.bungee.api.CommandSender; import net.md_5.bungee.api.ProxyServer; import net.md_5.bungee.api.chat.BaseComponent; import net.md_5.bungee.api.chat.TextComponent; import net.md_5.bungee.api.config.ServerInfo; import net.md_5.bungee.api.event.PluginMessageEvent; import net.md_5.bungee.api.plugin.Listener; import net.md_5.bungee.api.plugin.Plugin; import net.md_5.bungee.api.plugin.PluginManager; import net.md_5.bungee.chat.ComponentSerializer; import net.md_5.bungee.config.Configuration; import net.md_5.bungee.config.ConfigurationProvider; import net.md_5.bungee.config.YamlConfiguration; import net.md_5.bungee.event.EventHandler; import java.io.*; import java.lang.instrument.Instrumentation; import java.util.*; import java.util.concurrent.TimeUnit; import static com.lifeknight.relayutils.basic.Text.getSimpleDateFormat; import static net.md_5.bungee.api.ChatColor.*; public final class Main extends Plugin implements Listener { public static Main instance; public static final String CHANNEL = "relay:mc"; public static int uniquePlayers = 0; private static int tickCount = 0; private static boolean enabled; private final static String CONFIG_FILE = "relaymc.yml"; public static final long START_OF_2021 = 1609459200000L; private static final long SUNDAY_3_13_2022_4_AM = 1647158400000L; private static final long DATE_10_1_2023_4AM = 1696147200000L; public static final String DISCORD_URL = "https://discord.gg/tsMyACa4Yj"; public static final List<Map<Long, Integer>> playerCountLog = new ArrayList<>(); public static final Map<Long, Integer> onlineLog = new HashMap<>(); private static long nextRestart = SUNDAY_3_13_2022_4_AM; private static long restartTime = Long.MIN_VALUE; private static boolean restartMessageSent = false; public static boolean isRestarting = false; public static boolean maintenanceMode = true; public static boolean open = true; public static List<UUID> whitelistedPlayers = new ArrayList<>(); private static final Map<MainGame, File> MAIN_GAME_TO_PLUGIN = new HashMap<>(); private static long lastDailyReset = 0L; private static long lastWeeklyReset = 0L; private static long lastMonthlyReset = 0L; public static boolean queueOpen = true; public static String queueCloseMessage; public static int maxPlayers = 100; public static int infoMessageDelay = 15; private static BaseComponent[] latestInfoMessage = null; private static List<BaseComponent[]> infoMessages = Miscellaneous.processList(Miscellaneous.getList( RelayUtils.format("%sFound a bug with the server? Use %s/bugreport %sor join our Discord server and report it!", RED, DARK_PURPLE, RED), RelayUtils.format("%sHave any ideas for new minigames, or suggestions for the server? Join our discord with %s/discord %sand put it in #suggestions!", GREEN, DARK_GREEN, GREEN), RelayUtils.format("%sHave any questions about the server? Use %s/discord %sto join our Discord server and ask our staff.", YELLOW, DARK_PURPLE, YELLOW), RelayUtils.format("%sCaught a player who appears to be cheating? %sUse %s/DISCORD %sto join our Discord server to report them or use %s/report!", RED, YELLOW, DARK_PURPLE, YELLOW, RED), RelayUtils.format("%sCurious on how Manhunt has been enhanced on Relay? Join our Discord server with %s/discord %sto see!", YELLOW, DARK_PURPLE, YELLOW), RelayUtils.format("%sBuy ranks on our store (/store) to help us get more servers and expand our network!", YELLOW), RelayUtils.format("%sHelp our server grow by voting (/vote)!", GREEN)), s -> new BaseComponent[]{new TextComponent(s)}); public static long gamesPlayed = 0; public static long peakPlayers = 0; public static int newPlayers = 0; public static final List<Task> SCHEDULED_TASKS = new ArrayList<>(); private static File file; private static Configuration bungeeConfig; private static volatile Instrumentation globalInstrumentation; private static Map<GameType, Integer> gamesPlayedMap = new HashMap<>(); public static void premain(final String agentArgs, final Instrumentation inst) { globalInstrumentation = inst; } public static Instrumentation getInstrumentation() { return globalInstrumentation; } public static int getOnNetworkPlayerCount() { int i = 0; for (SmartPlayer onlineSmartPlayer : SmartPlayer.getOnlineSmartPlayers()) { if (onlineSmartPlayer.getServer() != null && !onlineSmartPlayer.getServer().isLimbo()) { i++; } } return i; } public static int getOnlineCount() { return SmartPlayer.getOnlineSmartPlayers().size(); } public static void onGamePlayed(GameType gameType1) { gamesPlayed++; gamesPlayedMap.put(gameType1, gamesPlayedMap.getOrDefault(gameType1, 0) + 1); } @Override public void onEnable() { instance = this; enabled = true; RelayUtils.setName("Proxy"); RelayUtils.setLogger(this.getLogger()); PluginManager pluginManager = this.getProxy().getPluginManager(); pluginManager.registerCommand(this, new RelayMCCommand()); pluginManager.registerCommand(this, new MaintenanceCommand()); pluginManager.registerCommand(this, new BroadcastCommand()); pluginManager.registerCommand(this, new SudoCommand()); pluginManager.registerCommand(this, new GroupCommand()); pluginManager.registerCommand(this, new PurchaseCommand()); pluginManager.registerCommand(this, new CreditsCommand()); pluginManager.registerCommand(this, new MessagesCommand()); pluginManager.registerCommand(this, new ManhuntQuitsCommand()); pluginManager.registerCommand(this, new ServersCommand()); pluginManager.registerCommand(this, new PunishmentsCommand()); pluginManager.registerCommand(this, new IPBanCommand()); pluginManager.registerCommand(this, new BanCommand()); pluginManager.registerCommand(this, new MuteCommand()); pluginManager.registerCommand(this, new WarnCommand()); pluginManager.registerCommand(this, new TempBanCommand()); pluginManager.registerCommand(this, new TempMuteCommand()); pluginManager.registerCommand(this, new TempWarnCommand()); pluginManager.registerCommand(this, new UnBanCommand()); pluginManager.registerCommand(this, new UnMuteCommand()); pluginManager.registerCommand(this, new ReportCommand()); pluginManager.registerCommand(this, new BugReportCommand()); pluginManager.registerCommand(this, new ReportsCommand()); pluginManager.registerCommand(this, new HelpCommand()); pluginManager.registerCommand(this, new StoreCommand()); pluginManager.registerCommand(this, new PremiumCommand()); pluginManager.registerCommand(this, new DiscordCommand()); pluginManager.registerCommand(this, new YouTubeCommand()); pluginManager.registerCommand(this, new TwitterCommand()); pluginManager.registerCommand(this, new VoteCommand()); pluginManager.registerCommand(this, new WhereAmICommand()); pluginManager.registerCommand(this, new PingCommand()); pluginManager.registerCommand(this, new PlayCommand()); pluginManager.registerCommand(this, new CancelCommand()); pluginManager.registerCommand(this, new RejoinCommand()); pluginManager.registerCommand(this, new DuelAcceptCommand()); pluginManager.registerCommand(this, new ManhuntAcceptCommand()); pluginManager.registerCommand(this, new ManhuntCommand()); pluginManager.registerCommand(this, new HubCommand()); pluginManager.registerCommand(this, new FriendCommand()); pluginManager.registerCommand(this, new FriendListCommand()); pluginManager.registerCommand(this, new BlockCommand()); pluginManager.registerCommand(this, new UnblockCommand()); pluginManager.registerCommand(this, new MessageCommand()); pluginManager.registerCommand(this, new ReplyCommand()); pluginManager.registerCommand(this, new PartyCommand()); pluginManager.registerCommand(this, new PartyListCommand()); pluginManager.registerCommand(this, new ChatCommand()); pluginManager.registerCommand(this, new AllChatCommand()); pluginManager.registerCommand(this, new PartyChatCommand()); pluginManager.registerCommand(this, new StaffChatCommand()); pluginManager.registerCommand(this, new SpectateCommand()); pluginManager.registerCommand(this, new NicknameCommand()); pluginManager.registerListener(this, this); pluginManager.registerListener(this, new Listeners()); this.getProxy().registerChannel(CHANNEL); this.readConfigurationFile(); this.saveConfigurationFile(); schedule(() -> { setupConfig(); MessageServer.start(RelayUtils.getPort()); }, 5); SmartDatabase.setup(); PlayerUtilities.startup(); BotUtils.startup(); RelayUtils.prepareProfileDatabase(); RelayUtils.prepareAllStatisticsTables(); RelayUtils.prepareLeaderboard(); RelayUtils.prepareGamePlayerDatabase(); RelayUtils.prepareArenaDatabase(); RelayUtils.prepareParkourTables(); RelayUtils.prepareCustomKitsLeaderboard(); RelayUtils.prepareCustomMapsLeaderboard(); updateNextRestartTime(); async(() -> { while (enabled) { try { this.onTick(); } catch (Exception e) { RelayUtils.printError("on tick", e); } if (enabled) { try { Thread.sleep(50); } catch (InterruptedException exception) { error("Tried to sleep thread, error occurred: %s", exception.getMessage()); } } } }); for (GameType ignored : Miscellaneous.filter(GameType.getGameTypes(), GameType::isEnabled)) { playerCountLog.add(new HashMap<>()); } SmartPlayer.getOrCreate("lifeknight"); } public static void addInfoMessage(BaseComponent[] components) { infoMessages.add(components); save(); } public void readConfigurationFile() { try { File dataFolder = this.getDataFolder(); if (!dataFolder.exists()) { dataFolder.mkdir(); } File fileConfiguration = new File(dataFolder, CONFIG_FILE); ConfigurationProvider configurationProvider = ConfigurationProvider.getProvider(YamlConfiguration.class); if (!fileConfiguration.exists()) { createPlaceholderServerList(); this.saveConfigurationFile(); } else { Configuration configuration = configurationProvider.load(fileConfiguration); RelayUtils.testing = configuration.getBoolean("testing"); try { infoMessages = Miscellaneous.processList( configuration.getStringList("infoMessages"), s -> ComponentSerializer.parse(ChatColor.translateAlternateColorCodes('&', s)) ); } catch (Exception exception) { error("An error occurred while reading info messages: %s", exception.getMessage()); } infoMessageDelay = configuration.getInt("infoMessageDelay", infoMessageDelay); lastMonthlyReset = configuration.getLong("lastMonthlyReset", System.currentTimeMillis()); lastWeeklyReset = configuration.getLong("lastWeeklyReset", System.currentTimeMillis()); lastDailyReset = configuration.getLong("lastDailyReset", System.currentTimeMillis()); setLastResetTimes(); maxPlayers = configuration.getInt("maxPlayers", maxPlayers); maintenanceMode = configuration.getBoolean("maintenance", true); whitelistedPlayers = Miscellaneous.processList(configuration.getStringList("whitelist"), RelayUtils::getUUID); Server.clear(); for (MainGame value : MainGame.values()) { List<String> hubNames = configuration.get(value.getComparableName() + "Hubs", new ArrayList<>()); List<String> serverNames = configuration.get(value.getComparableName() + "Servers", new ArrayList<>()); for (String hubName : hubNames) { Server.create(hubName, value, ServerType.HUB); } for (String serverName : serverNames) { Server.create(serverName, value, ServerType.GAME); } } List<String> mainHubNames = configuration.get("mainHubs", new ArrayList<>()); for (String mainHubName : mainHubNames) { Server.create(mainHubName, null, ServerType.HUB); } List<String> limboNames = configuration.get("limbos", new ArrayList<>()); for (String limboName : limboNames) { Server.create(limboName, null, ServerType.LIMBO); } } for (File file : dataFolder.listFiles((dir, name) -> name.contains(".jar"))) { for (MainGame mainGame : MainGame.values()) { if (Text.toComparable(file.getName()).contains(mainGame.getComparableName())) { if (MAIN_GAME_TO_PLUGIN.containsKey(mainGame)) { File current = MAIN_GAME_TO_PLUGIN.get(mainGame); Version currentV = Utilities.parseVersion(current.getName()); Version newV = Utilities.parseVersion(file.getName()); if (newV.isGreater(currentV)) { info("Remapping %s with %s.", file.getName(), mainGame.getComparableName()); MAIN_GAME_TO_PLUGIN.put(mainGame, file); } } else { info("Mapping %s with %s.", file.getName(), mainGame.getComparableName()); MAIN_GAME_TO_PLUGIN.put(mainGame, file); } break; } } if (!MAIN_GAME_TO_PLUGIN.containsValue(file)) { info("Setting %s as hub plugin.", file.getName()); MAIN_GAME_TO_PLUGIN.put(null, file); } } } catch (Exception exception) { error("An error occurred in the reading of the configuration file: %s", exception.getMessage()); this.saveConfigurationFile(); } updatePlugins(); } private void setLastResetTimes() { lastDailyReset = SUNDAY_3_13_2022_4_AM; while (lastDailyReset + 24 * 60 * 60 * 1000L < System.currentTimeMillis()) { lastDailyReset += 24 * 60 * 60 * 1000L; } lastWeeklyReset = SUNDAY_3_13_2022_4_AM; while (lastWeeklyReset + 7 * 24 * 60 * 60 * 1000L < System.currentTimeMillis()) { lastWeeklyReset += 7 * 24 * 60 * 60 * 1000L; } lastMonthlyReset = DATE_10_1_2023_4AM; while (lastMonthlyReset + 30 * 24 * 60 * 60 * 1000L < System.currentTimeMillis()) { lastMonthlyReset += 30 * 24 * 60 * 60 * 1000L; } } public static void reload() { instance.readConfigurationFile(); } public static void save() { instance.saveConfigurationFile(); } public void saveConfigurationFile() { try { File dataFolder = this.getDataFolder(); if (!dataFolder.exists()) { dataFolder.mkdir(); } File fileConfiguration = new File(dataFolder, CONFIG_FILE); ConfigurationProvider configurationProvider = ConfigurationProvider.getProvider(YamlConfiguration.class); if (!fileConfiguration.exists()) { fileConfiguration.createNewFile(); } Configuration configuration = configurationProvider.load(fileConfiguration); configuration.set("port", RelayUtils.PROXY_MESSAGE_SERVER_PORT); configuration.set("testing", RelayUtils.testing); configuration.set("infoMessages", Miscellaneous.processList(infoMessages, ComponentSerializer::toString)); configuration.set("infoMessageDelay", infoMessageDelay); configuration.set("lastDailyReset", lastDailyReset); configuration.set("lastWeeklyReset", lastWeeklyReset); configuration.set("lastMonthlyReset", lastMonthlyReset); configuration.set("maxPlayers", maxPlayers); configuration.set("whitelist", Miscellaneous.processList(whitelistedPlayers, RelayUtils::getName)); for (MainGame value : MainGame.values()) { configuration.set(value.getComparableName() + "Hubs", Miscellaneous.processList(Server.getServersOfType(value, false), Server::getName)); configuration.set(value.getComparableName() + "Servers", Miscellaneous.processList(Server.getServersOfType(value, true), Server::getName)); } configuration.set("mainHubs", Miscellaneous.processList(Server.getServersOfType(null, false), Server::getName)); configuration.set("limbos", Miscellaneous.processList(Server.getLimboServers(), Server::getName)); configurationProvider.save(configuration, fileConfiguration); } catch (Exception exception) { exception.printStackTrace(); } } @Override public void onDisable() { enabled = false; this.getProxy().unregisterChannel(CHANNEL); this.logPlayerCounts(); MessageServer.end(); SmartDatabase.shutdown(); BotUtils.shutdown(); info("Disabled."); } @EventHandler public void onPluginMessageReceived(PluginMessageEvent event) { if (event.getTag().equalsIgnoreCase(CHANNEL)) { try { ByteArrayDataInput in = ByteStreams.newDataInput(event.getData()); Message message = Message.fromJson(RelayUtils.parseJsonArray(in.readUTF())); onMessageReceived(message); } catch (Exception exception) { error("An error occurred while trying to process message: %s", exception.getMessage()); } } } public static void onMessageReceived(Message message) { Recipient recipient = message.getRecipientRecipient(); if (!(Recipient.PROXY == recipient || Recipient.NONE == recipient)) { try { MessageServerHandler.sendMessageToServer(message); } catch (Exception exception) { error("Attempted to forward a message to a server, no server found (%s): %s", MessageServerHandler.CHANNELS.keySet(), message); } } else { try { ServerMessageProcessor.processMessage(message); } catch (Exception exception) { RelayUtils.printError("process message", exception, 8); } } } public void onTick() { log("on tick"); tickCount++; if (restartTime != Long.MIN_VALUE && System.currentTimeMillis() >= restartTime && !isRestarting) { restart(); return; } if (isOfSeconds(10)) { broadcastPlayerCounts(); broadcastHubs(); } if (!RelayUtils.testing && isOfSeconds(5)) { BotUtils.updatePlayerCount(isOfSeconds(10)); } if (isOfSeconds(1)) { broadcastPing(); disconnectInactive(); boolean update = false; if (lastDailyReset != 0 && System.currentTimeMillis() - lastDailyReset >= getTimeRequired(0)) { update = true; this.resetLeaderboard(0); } if (lastWeeklyReset != 0 && System.currentTimeMillis() - lastWeeklyReset >= getTimeRequired(1)) { update = true; this.resetLeaderboard(1); } if (lastMonthlyReset != 0 && System.currentTimeMillis() - lastMonthlyReset >= getTimeRequired(2)) { update = true; this.resetLeaderboard(2); } if (update) { RelayUtils.prepareLeaderboard(); RelayUtils.prepareCustomKitsLeaderboard(); RelayUtils.prepareCustomMapsLeaderboard(); } } if (isOfSeconds(180)) { sendStatsMessage(); } if (tickCount % (infoMessageDelay * 60 * 20) == 0) { synchronous(Main::broadcastInfoMessage); } if (Miscellaneous.isWithinRange(nextRestart, System.currentTimeMillis(), 30 * 60 * 1000L) && !restartMessageSent) { Main.info("Scheduling restart for normal restarts."); scheduleRestart(); } else if (Miscellaneous.getRemainingMemoryMegaBytes() <= 64 && !restartMessageSent) { warn("Scheduling restart. (Remaining memory: %d MB)", Miscellaneous.getRemainingMemoryMegaBytes()); scheduleRestart(10 * 60 * 1000L); } SmartPlayer.onTick(); runScheduledTasks(); } private void runScheduledTasks() { List<Integer> delete = new ArrayList<>(); SCHEDULED_TASKS.removeIf(Objects::isNull); for (int i = 0; i < SCHEDULED_TASKS.size(); i++) { Task scheduledTask = SCHEDULED_TASKS.get(i); try { if (System.currentTimeMillis() - scheduledTask.initialize >= scheduledTask.waitTime) { delete.add(i); scheduledTask.runnable.run(); } } catch (Exception e) { RelayUtils.printError("run a schedule task", e, 5); BotUtils.onScheduledTaskError(e); } } for (Integer integer : Miscellaneous.reverse(delete)) { SCHEDULED_TASKS.remove((int) integer); } } private void logPlayerCounts() { List<GameType> gameTypes = Miscellaneous.filter(GameType.getGameTypes(), GameType::isEnabled); long time = System.currentTimeMillis(); for (int i = 0; i < gameTypes.size(); i++) { playerCountLog.get(i).put(time, getPlayerCount(gameTypes.get(i))); } onlineLog.put(time, SmartPlayer.getOnlineSmartPlayers().size()); updatePlayerCountLog(); } public static void updatePlayerCountLog() { Map<Long, Integer> totals = new HashMap<>(); for (int j = 0; j < playerCountLog.get(0).size(); j++) { for (Map<Long, Integer> longIntegerMap : playerCountLog) { Map.Entry<Long, Integer> val = Miscellaneous.getList(longIntegerMap.entrySet()).get(j); totals.put(val.getKey(), totals.getOrDefault(val.getKey(), 0) + val.getValue()); } } StringBuilder csv = new StringBuilder(); csv.append("Time (epoch),Online,In-Game"); for (GameType gameType : Miscellaneous.filter(GameType.getGameTypes(), GameType::isEnabled)) { csv.append(",").append(gameType.getFullPrettyName()); } csv.append("\n"); for (Long aLong : totals.keySet()) { csv.append(aLong).append(","); csv.append(onlineLog.get(aLong)).append(","); csv.append(totals.get(aLong)); for (Map<Long, Integer> longIntegerMap : playerCountLog) { csv.append(","); csv.append(longIntegerMap.get(aLong)); } csv.append("\n"); } try { File folder = new File(instance.getDataFolder(), "/logs/playercounts"); if (!folder.exists()) { folder.mkdirs(); } File file1 = new File(folder, getDateTimeString(RelayUtils.INITIALIZATION_TIME).replace(":", "-").replace("/", "-").replace(" ", "-") + ".txt"); if (!file1.exists()) { file1.createNewFile(); } PrintWriter writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file1))); writer.write(csv.toString()); writer.close(); } catch (Exception exception) { error("Could not write to log file: %s", exception.getMessage()); } try { File folder = new File(instance.getDataFolder(), "/logs/reports"); if (!folder.exists()) { folder.mkdirs(); } File file1 = new File(folder, "Reports " + getDateTimeString(RelayUtils.INITIALIZATION_TIME).replace(":", "-").replace("/", "-").replace(" ", "-") + ".txt"); if (!file1.exists()) { file1.createNewFile(); } PrintWriter writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file1))); writer.write(getReport()); writer.close(); } catch (Exception exception) { error("Could not write to log file (2): %s", exception.getMessage()); } } private static String getReport() { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("Uptime: ").append(Text.getShortTextualFormattedTime(System.currentTimeMillis() - RelayUtils.INITIALIZATION_TIME)).append("\n"); stringBuilder.append("Peak Players: ").append(peakPlayers).append("\n"); stringBuilder.append("Unique Players: ").append(uniquePlayers).append("\n"); stringBuilder.append("New Players: ").append(newPlayers).append("\n"); stringBuilder.append("Games Played: ").append("\n"); stringBuilder.append("Total: ").append(gamesPlayed).append("\n"); for (Map.Entry<GameType, Integer> gameTypeIntegerEntry : gamesPlayedMap.entrySet()) { stringBuilder.append(" - ").append(gameTypeIntegerEntry.getKey().getFullPrettyName()).append(": ").append(gameTypeIntegerEntry.getValue()).append("\n"); } return stringBuilder.toString(); } public static String getDateTimeString(long milliseconds) { return getSimpleDateFormat("MM/dd/yyyy HH:mm:ss").format(milliseconds) + " EST"; } private int getPlayerCount(GameType gameType) { int count = 0; for (GameServer gameServer : GameServer.GAME_SERVERS) { ServerDetails details = gameServer.getServerDetails(); if (details == null) { warn("Details were null: %s", gameServer.getRecipient()); } else { for (GameDetails gameDetail : details.gameDetails) { if (gameDetail != null && gameDetail.getGameType() == gameType) { count += gameDetail.getPlayerCount(); } } } } return count; } public static void scheduleRestart(long time) { ComponentBuilder componentBuilder = new ComponentBuilder(ComponentBuilder.RED).line().newLine().color(ComponentBuilder.YELLOW); componentBuilder.append("The network will be restarting in ").color(ComponentBuilder.RED_ORANGE).append(Text.formatTimeFromMilliseconds(time)).color(ComponentBuilder.YELLOW).append(" to improve performance.").newLine(); componentBuilder.color(ComponentBuilder.RED).line(); queueOpen = false; queueCloseMessage = RED + "The network will be restarting at " + Text.getTimeString(System.currentTimeMillis() + time); restartMessageSent = true; restartTime = System.currentTimeMillis() + time; } public static void restart() { info("---------------\nRESTARTING SERVER\n---------------"); isRestarting = true; for (SmartPlayer onlineSmartPlayer : SmartPlayer.getOnlineSmartPlayers()) { if (!onlineSmartPlayer.isStaff()) { onlineSmartPlayer.kick("The network is restarting. Try joining in 60 seconds."); } } schedule(RelayUtils::restart, 10); } public static void scheduleRestart() { scheduleRestart(30 * 60 * 1000L); } public static void sendStatsMessage(CommandSender commandSender) { ComponentBuilder componentBuilder = new ComponentBuilder(); componentBuilder.color(ComponentBuilder.GREEN); componentBuilder.append("Up Since: %s (%s)", Text.getDateTimeString(RelayUtils.INITIALIZATION_TIME), Text.getShortTextualFormattedTime(System.currentTimeMillis() - RelayUtils.INITIALIZATION_TIME)).newLine(); long restart = restartMessageSent ? restartTime : nextRestart; componentBuilder.append("Restart time: %s (in %s)", Text.getDateTimeString(restart), Text.getShortTextualFormattedTime(restart - System.currentTimeMillis())).newLine(); componentBuilder.append("SmartPlayer count: %d", SmartPlayer.SMART_PLAYERS.size()).newLine(); componentBuilder.append("Unique Players: %d", uniquePlayers).newLine(); componentBuilder.append("New Players: %d", newPlayers).newLine(); componentBuilder.append("Online: %d", SmartPlayer.getOnlineSmartPlayers().size()).newLine(); componentBuilder.append("In Game: %d", GameServer.getPlayersInGame()).newLine(); componentBuilder.append("Games Played: %d", gamesPlayed).newLine(); componentBuilder.append("Peak Players: %d", peakPlayers).newLine(); componentBuilder.append("MB of memory: %d", Miscellaneous.getRemainingMemoryMegaBytes()).newLine(); commandSender.sendMessage(componentBuilder.getResult()); } public static void sendStatsMessage() { sendStatsMessage(instance.getProxy().getConsole()); } public static void open() { open = true; } public static void async(Runnable runnable) { log("async"); ProxyServer.getInstance().getScheduler().runAsync(instance, runnable); } public static File getPlugin(Server server) { if (server == null) return null; if (server.isHub() || server.isLimbo()) { return MAIN_GAME_TO_PLUGIN.get(null); } return MAIN_GAME_TO_PLUGIN.get(server.getMainGame()); } public static void restartGameServers() { for (Server gameServer : Server.getGameServers()) { if (gameServer.isActive() && gameServer.isEmpty()) { gameServer.sendMessage(Command.RESTART); } } info("Restarted empty game servers."); } public static void restartHubs() { for (Server hubServer : Server.getHubServers()) { if (hubServer.isActive() && hubServer.isEmpty()) { hubServer.sendMessage(Command.RESTART); } } info("Restarted empty hubs."); } public static void startServers() { for (Server server : Miscellaneous.with(Server.getGameServers(), Server.getHubServers())) { if (!server.isActive()) { server.start(); } } } public static boolean isSecond() { return isOfSeconds(1); } public static boolean isOfSeconds(int seconds) { return tickCount % (20 * seconds) == 0; } public static void updateNextRestartTime() { int iteration = 0; while (nextRestart < System.currentTimeMillis()) { switch (iteration) { case 0: case 2: nextRestart += 2 * 24 * 60 * 60 * 1000L; break; case 1: nextRestart += 3 * 24 * 60 * 60 * 1000L; break; } if (iteration == 2) { iteration = 0; } else { iteration++; } } } public void resetLeaderboard(int i) { String leaderboardName = ""; if (i == 1) { leaderboardName = "weekly"; lastWeeklyReset = System.currentTimeMillis(); } else if (i == 0) { leaderboardName = "daily"; lastDailyReset = System.currentTimeMillis(); } else if (i == 2) { leaderboardName = "monthly"; lastMonthlyReset = System.currentTimeMillis(); } for (String leaderboard : Miscellaneous.getList("leaderboard", SmartDatabase.CUSTOM_MAP_TABLE_NAME, SmartDatabase.CUSTOM_KIT_TABLE_NAME)) { SmartDatabase.executeUpdate("TRUNCATE `%s`", leaderboard + "_" + leaderboardName); } schedule(() -> Utilities.broadcast("%s%s leaderboards %s%shave been reset!", GREEN, i == 1 ? "Weekly" : (i == 0 ? "Daily" : "Monthly"), AQUA, BOLD), 60); for (Server gameServer : Server.getGameServers()) { if (gameServer.isActive()) { gameServer.sendMessage(Command.OTHER, "leaderboard_reset", "leaderboard_" + leaderboardName); } } this.saveConfigurationFile(); } public static long getTimeRequired(int i) { if (i == 0) { return 24 * 60 * 60 * 1000L; } if (i == 2) { return 30 * 24 * 60 * 60 * 1000L; } return 7 * 24 * 60 * 60 * 1000L; } public static void info(String format, Object... data) { instance.getLogger().info(RelayUtils.format(format, data)); } public static void warn(String format, Object... data) { instance.getLogger().warning(RelayUtils.format(format, data)); } public static void error(String format, Object... data) { instance.getLogger().severe(RelayUtils.format(format, data)); } public static void log(String format, Object... data) { RelayUtils.log(format, data); } public static void schedule(Runnable runnable, long seconds) { schedule(runnable, seconds, TimeUnit.SECONDS); } public static void scheduleMillis(Runnable runnable, long milliseconds) { schedule(runnable, milliseconds, TimeUnit.MILLISECONDS); } public static void schedule(Runnable runnable, long time, TimeUnit timeUnit) { SCHEDULED_TASKS.add(new Task(runnable, System.currentTimeMillis(), timeUnit.toMillis(time))); /* ProxyServer.getInstance().getScheduler().schedule(instance, () -> { }, time, timeUnit); */ } public static void synchronous(Runnable runnable) { schedule(runnable, 0); } public static void broadcastPlayerCounts() { Map<GameType, Integer> gameTypeToCount = new HashMap<>(); for (GameType gameType : GameType.getGameTypes(false, false)) { gameTypeToCount.put(gameType, 0); } for (GameServer gameServer : GameServer.GAME_SERVERS) { ServerDetails details = gameServer.getServerDetails(); if (details == null) { warn("Details were null: %s", gameServer.getRecipient()); return; } for (GameDetails gameDetail : details.gameDetails) { if (gameDetail != null && gameDetail.getGameType() != null) { int currentCount = gameTypeToCount.get(gameDetail.getGameType()); gameTypeToCount.put(gameDetail.getGameType(), currentCount + gameDetail.getPlayerCount()); } } } for (GameType gameType : GameType.getGameTypes(false, false)) { int count = gameTypeToCount.get(gameType); gameTypeToCount.put(gameType, count + Queue.getQueueSize(gameType)); } StringBuilder stringBuilder = new StringBuilder(); for (GameType gameType : gameTypeToCount.keySet()) { stringBuilder.append(gameType.toString()).append(":").append(gameTypeToCount.get(gameType)).append(","); } sendMessageToHubs(new Message(Command.PLAYER_COUNT, stringBuilder.toString())); } public static void broadcastHubs() { JsonArray jsonArray = new JsonArray(); for (MainGame mainGame : Miscellaneous.with(Miscellaneous.getList(MainGame.values()), (MainGame) null)) { JsonObject hubGroup = new JsonObject(); hubGroup.addProperty("type", mainGame == null ? "main" : mainGame.getComparableName()); JsonArray hubsOfType = new JsonArray(); for (Server server : Server.getAvailableServersOfType(mainGame, false)) { JsonObject hub = new JsonObject(); hub.addProperty("name", server.getName()); hub.addProperty("count", server.getPlayerCount()); hubsOfType.add(hub); } hubGroup.add("hubs", hubsOfType); jsonArray.add(hubGroup); } sendMessageToHubs(new Message(Command.HUBS, jsonArray)); } public static void broadcastPublicQueues() { JsonObject games = new JsonObject(); JsonArray currentGames = new JsonArray(); JsonArray queuedGames = new JsonArray(); for (QueueData customKitsDatum : GameServer.getGameData()) { currentGames.add(customKitsDatum.toString()); } for (QueueData customKitsDatum : Queue.getQueuedGames()) { queuedGames.add(customKitsDatum.toString()); } games.add("current", currentGames); games.add("queued", queuedGames); sendMessageToHubs(new Message(Command.OTHER, "duelsgames", games)); } public static void broadcastPing() { sendMessageToGameServers(new Message(Command.OTHER, "ping")); sendMessageToHubs(new Message(Command.OTHER, "ping")); } public static void disconnectInactive() { for (MessageServerHandler messageServerHandler : getMessageServerHandlers()) { if (Miscellaneous.enoughTimeHasPassed(messageServerHandler.getLastPing(), 3, TimeUnit.SECONDS)) { messageServerHandler.closeConnection(); } } } public static void broadcastInfoMessage() { BaseComponent[] next = Miscellaneous.getNextIndex(infoMessages, latestInfoMessage); if (next != null) { for (SmartPlayer onlineSmartPlayer : SmartPlayer.getOnlineSmartPlayers()) { if (onlineSmartPlayer.isOnHub()) { onlineSmartPlayer.sendMessage(next); } } } latestInfoMessage = next; } public static void setMaintenanceMode(boolean mode) { maintenanceMode = mode; if (maintenanceMode) { ComponentBuilder componentBuilder = new ComponentBuilder(); componentBuilder.color(ComponentBuilder.YELLOW); componentBuilder.line().newLine(); componentBuilder.color(ComponentBuilder.RED_ORANGE).append("Server is entering").color(ComponentBuilder.ORANGE_YELLOW).bold().append(" MAINTENANCE MODE!").newLine(); componentBuilder.color(ComponentBuilder.YELLOW).line(); Utilities.broadcast(componentBuilder); schedule(() -> { ComponentBuilder kickMessage = new ComponentBuilder(); kickMessage.color(ComponentBuilder.BLUE).append("Relay").newLine().newLine(); kickMessage.color(ComponentBuilder.YELLOW).append("Relay has entered maintenance mode.").newLine(); kickMessage.color(DARK_PURPLE).append("Discord: ").link(Main.DISCORD_URL, true); for (SmartPlayer onlineSmartPlayer : SmartPlayer.getOnlineSmartPlayers()) { if (!(onlineSmartPlayer.isStaff() || whitelistedPlayers.contains(onlineSmartPlayer.getUUID()))) { onlineSmartPlayer.kick(kickMessage); } } }, 3); } } public static List<MessageServerHandler> getMessageServerHandlers() { List<MessageServerHandler> list = Miscellaneous.getList(MessageServerHandler.CHANNELS.values()); list.removeIf(Objects::isNull); return list; } public static void updatePlugins() { List<MessageServerHandler> messageServerHandlers = getMessageServerHandlers(); for (int i = 0; i < messageServerHandlers.size(); i++) { int finalI = i; scheduleMillis(() -> { MessageServerHandler messageServerHandler = messageServerHandlers.get(finalI); messageServerHandler.getPluginVersion(); }, 500L * i); } } public static void sendMessageToHubs(Message message) { for (MessageServerHandler messageServerHandler : getMessageServerHandlers()) { if (messageServerHandler.hasServer() && messageServerHandler.getServer().isHub()) { messageServerHandler.sendMessage(message); } } } public static void sendMessageToGameServers(Message message) { for (MessageServerHandler messageServerHandler : getMessageServerHandlers()) { if (messageServerHandler.hasServer() && !messageServerHandler.getServer().isHub()) { messageServerHandler.sendMessage(message); } } } public static void createPlaceholderServerList() { createPlaceholderServers(null, "hub", 3, ServerType.HUB); createPlaceholderServers(null, "z", 3, ServerType.LIMBO); for (MainGame value : MainGame.values()) { String prefix = getPrefix(value.getName()); createPlaceholderServers(value, prefix + "lobby", 3, ServerType.HUB); createPlaceholderServers(value, prefix, 10, ServerType.GAME); } } public static String getPrefix(String name) { StringBuilder stringBuilder = new StringBuilder(); for (String s : name.split(" ")) { stringBuilder.append(Character.toLowerCase(s.charAt(0))); } return stringBuilder.toString(); } public static void createPlaceholderServers(MainGame mainGame, String prefix, int count, ServerType serverType) { for (int i = 0; i < count; i++) { Server.create(prefix + get1000Number(i + 1), mainGame, serverType); } } public static String get1000Number(int number) { if (number < 10) { return "00" + number; } if (number < 100) { return "0" + number; } return String.valueOf(number); } public static void addToConfig(ServerInfo serverInfo) { if (bungeeConfig == null) { return; } bungeeConfig.set("servers." + serverInfo.getName() + ".motd", serverInfo.getMotd().replace(ChatColor.COLOR_CHAR, '&')); bungeeConfig.set("servers." + serverInfo.getName() + ".address", Utilities.socketAddressToString(serverInfo.getSocketAddress())); bungeeConfig.set("servers." + serverInfo.getName() + ".restricted", serverInfo.isRestricted()); saveBungeeConfig(); } public static void removeFromConfig(ServerInfo serverInfo) { removeFromConfig(serverInfo.getName()); } public static void removeFromConfig(String name) { if (bungeeConfig == null) { return; } bungeeConfig.set("servers." + name, null); saveBungeeConfig(); } private static void saveBungeeConfig() { if (bungeeConfig == null) { return; } try { YamlConfiguration.getProvider(YamlConfiguration.class).save(bungeeConfig, file); } catch (IOException e) { e.printStackTrace(); } } private static void setupConfig() { FileInputStream fis = null; InputStreamReader isr = null; try { file = new File(ProxyServer.getInstance().getPluginsFolder().getParentFile(), "config.yml"); fis = new FileInputStream(file); isr = new InputStreamReader(fis); bungeeConfig = YamlConfiguration.getProvider(YamlConfiguration.class).load(isr); } catch (IOException e) { e.printStackTrace(); } finally { try { if (fis != null) { fis.close(); } if (isr != null) { isr.close(); } } catch (IOException ignored) { } } } public static boolean networkIsFull() { return networkIsFull(false); } public static boolean networkIsFull(boolean excludeOne) { if (excludeOne) { return Main.getOnNetworkPlayerCount() > Main.maxPlayers || Server.allHubsAreFull(); } return Main.getOnNetworkPlayerCount() >= Main.maxPlayers || Server.allHubsAreFull(); } public static void doAndLogDuration(String name, Runnable action) { long startTime = System.currentTimeMillis(); action.run(); if (RelayUtils.log) { info("Time taken for %s: %s", name, Text.addCommasToNumber(System.currentTimeMillis() - startTime)); } } private record Task(Runnable runnable, long initialize, long waitTime) { } }